Variable not found

Borrado de registros con jqGrid y ASP.NET MVC

2009-11-24T23:39:00.000+01:00

En un post anterior dedicado a jqGrid y ASP.NET MVC vimos lo sencillo que resultaba implementar un potente grid para mostrar datos tabulares, permitiendo paginación, ordenación y redimensionado de columnas.

Pero, como ya comenté entonces, jqGrid es mucho más que eso. En este artículo estudiaremos la implementación de la funcionalidad de borrado de filas integrada en el propio componente, utilizando intercambio de datos Ajax con el lado servidor para actualizar el modelo.

Partiremos del ejemplo que desarrollamos anteriormente, y nos centraremos únicamente en introducir los cambios necesarios para introducir esta nueva capacidad. También, como en el caso anterior, encontraréis al final un enlace al proyecto de demostración, para Visual Web Developer Express 2008 SP1 y ASP.NET MVC 1.0.

1. Preparamos la infraestructura

Antes de nada, y es algo que es importante recordar cuando trabajemos con jqGrid, debemos pensar qué módulos de este componente necesitamos en nuestro proyecto.

En el post anterior descargamos exclusivamente los necesarios para implementar la visualización del grid; ahora, dado que vamos a utilizar más funcionalidades del componente, debemos seleccionar en la herramienta de descarga aquellos que nos harán falta, el base y los relativos a la edición de datos.

En teoría deberíamos seleccionar los módulos estrictamente necesarios para nuestros fines, pero en la práctica no es fácil adivinar cuál de ellos implementa justamente lo que estamos buscando. De hecho, es bastante frecuente encontrarse con errores de script cuando no acertamos con el módulo exacto, al que siguen bastantes iteraciones prueba-error hasta que conseguimos averiguar cuál debemos indicar en la descarga.

Por eso en este caso, seleccionaremos todos los módulos relativos a la edición; eso nos permitirá, además, seguir implementando funcionalidades como el alta o la modificación sin tener que volver a descargar componentes.

Aparte de los módulos a incluir en la descarga, el resto de los pasos de preparación de la infraestructura son idénticos a los descritos en los puntos 1 al 3 del post inicial:

Copiar los archivos de script (jqGrid y el archivo de localización) en el proyecto.
Descargar el tema visual de jQuery UI y añadirlo al proyecto.
referenciar las librerías de scripts y estilos en la master (o vistas donde vayamos a usarlo).

2. El modelo

Vamos a ampliar la clase GestorDeAmigos anterior para que sea capaz de emular el almacenamiento en una base de datos, pero utilizando como soporte una colección en memoria que haremos persistir en una variable de aplicación. Además, aprovecharemos para añadirle un método Delete() que nos permita eliminar del almacén la persona cuyo “Id” le pasemos como parámetro.

public bool Delete(int id)

    Amigo amigo = DatosAmigos.FirstOrDefault(a => a.Id == id);

    if (amigo == null)

        return false;

    DatosAmigos.Remove(amigo);

    return true;

No profundizaré más en el modelo, pues el código es de lo más convencional. El que tenga curiosidad por ver cómo se implementa el almacén en una variable de aplicación, que acuda al fuente del proyecto de demostración.

3. La vista

En la vista debemos hacer muy pocos ajustes para permitir la eliminación de los datos. Básicamente, tendremos que habilitar un panel de botones en el grid, indicar que deseamos que aparezca el botón de eliminación, y configurar el comportamiento de éste, para lo cual invocaremos al método navGrid() después de la llamada de inicialización del grid que ya vimos el otro día:

<script type="text/javascript">

    jQuery(document).ready(function() {

        jQuery("#list").jqGrid({

            [...] // OMITIDO. Idéntico al del post anterior.

});

        $("#list").navGrid(

                null,

                { refresh: true, add: false, edit: false, del: true, search: false },

                null, // parámetros para el alta

                null, // parámetros para la edición

                {     // parámetros para la eliminación

                    url: '<%= Url.Action("Eliminar") %>',

                    width: 500,

                    afterSubmit: function(r, d) {

                        return [r.responseText=="", r.responseText];

);

});

Los parámetros que estamos pasando al método navGrid() son los siguientes:

el primer parámetro debería ser jQuery('#pager'), que es la referencia hacia el control de paginación que estamos utilizando. En este caso es un nulo porque esta referencia se incluyó en la inicialización de jqGrid.
A continuación, creamos un objeto anónimo en el que establecemos a true las propiedades del y refresh, que indica que queremos mostrar los botones de eliminación y recarga de datos. El resto de propiedades predefinidas, add, edit, y search, equivalentes a los botones de añadir, editar y buscar registros, respectivamente, las establecemos a false con objeto de que no aparezcan botones para invocarlas; ya las activaremos en otros posts ;-)
el siguiente parámetro se trata de un objeto donde configuramos el comportamiento del botón de alta de registros. Dado que no vamos a implementarlo ahora, lo establecemos a nulo.
el cuarto parámetro es lo mismo que el anterior, pero para configurar la edición, por lo que también se encuentra establecido a null.
a continuación, y por último, el objeto en cuyas propiedades definimos el comportamiento del botón de eliminación:
- La URL a la acción que se invocará en servidor, que la obtenemos utilizando el UrlHelper de MVC. En este caso, invocaremos a una acción llamada “Eliminar”, a la que el sistema enviará el Id del registro activo.
- El ancho del cuadro de diálogo de confirmación.
- En afterSubmit implementamos una función callback que jqGrid llamará cuando haya recibido el resultado de la petición Ajax. El primer parámetro que nos envía es el objeto XMLHttpRequest donde encontraremos la respuesta obtenida desde el servidor; el segundo parámetro contiene los datos que han sido enviados a la petición.
  
  El retorno de la función callback debe ser siempre un array con dos elementos. El primero es un booleano indicando si la eliminación ha tenido éxito, y el segundo es el mensaje de error, en caso de que se haya producido:
```
return [ exito , "mensaje de error" ];
```
  Es importante ahora resaltar una cosa: salvo los parámetros de entrada y el tipo de retorno descritos anteriormente, jqGrid no nos impone ninguna particularidad más respecto a cómo debemos implementar este método, el tipo de información que recibiremos desde el controlador o cómo la procesaremos al recibirla. Somos totalmente libres de elegir la forma en la que haremos las cosas.
  
  En nuestro caso, vamos a hacer una implementación muy simple en base a la siguiente convención: el controlador retornará un string con una descripción del error en caso de que se produzca algún problema borrando el registro, y retornará un nulo cuando todo vaya bien. Esto nos permite implementar el callback utilizando la siguiente expresión:

return [r.responseText=="", r.responseText];

4. El controlador

Dado que la lógica la tenemos implementada en el modelo, y que la vista ya está preparada para ponerse en contacto con el controlador vía Ajax y para recibir el feedback sobre el éxito de la operación, sólo nos queda implementar muy rápidamente el método de acción:

public ActionResult Eliminar(int id)

    if (!gestorDeAmigos.Delete(id))

        return Content("Error eliminando el registro");

    return null;

Podréis observar que si se produce un error, retornamos un ContentResult describiendo el problema; en otros casos, devolvemos un nulo.

Para probar el funcionamiento de una eliminación errónea podéis, por ejemplo, abrir dos navegadores contra la aplicación, borrar un registro desde uno de ellos e intentar borrarlo también desde el otro.

Y… ¡Voilá!

Una vez habiendo implementado el modelo, la vista y el controlador, sólo nos queda probar la aplicación, que veremos que funciona perfectamente ;-P

Resumiendo, en este post hemos seguido profundizando en las capacidades de jqGrid, implementando paso a paso la funcionalidad de eliminación de registros. Hemos podido observar también el escaso código (¡a pesar de la longitud del post!) que hay que añadir para disponer de esta funcionalidad, y de lo sencillo y reutilizable que resulta su implementación.

Descargar proyecto de demostración:

Publicado en: Variable not found.

Hojas con estilo usando .less

2009-11-23T11:07:00.001+01:00

Seguro que más de una vez has sufrido de lo lindo al tocar un archivo de hoja de estilos. Suelen estar mal organizados, ser muy extensos, difíciles de mantener, hay declaraciones duplicadas por todas partes… Y seguro que siempre te has preguntado si hay otra forma menos complicada de conseguir lo mismo.

K. Scott Allen nos habla en su post Keeping CSS Files DRY de .Less (dot less), un interesante componente portado del mundo Ruby capaz de “compilar” hojas de estilo que utiliza una notación extendida y mucho más potente del estándar CSS, permitiendo las siguientes características:

Uso de variables. Less permite declarar y utilizar variables para los valores que utilizaremos frecuentemente en nuestra hoja de estilos, así:
```
@nice-blue: #5B83AD;
```
```
 
```
```
#header { color: @light-blue; }
```
```
#footer { color: @light-blue; }
```
Operaciones. Podemos utilizar expresiones para obtener valores, por ejemplo:
```
@base: 5%;
```
```
@filler: @base * 2;
```
```
@other: @base + @filler;
```
```
 
```
```
color: #888 / 4;
```
```
background-color: @base-color + #111;
```
```
height: 100% / 2 + @filler;
```
Fijaos en un detalle de lo más interesante: Less es capaz de distinguir cuándo está operando con colores y cuándo con unidades, ofreciendo el resultado correcto en cada caso.
Mezclas (mixins), otra potente capacidad de Less que seguro que puede venirnos bastante bien, que consiste en incluir dentro de un conjunto de reglas dentro de otro, sólo haciendo referencia a su selector:
```
.bordered {
```
```
  border-top: dotted 1px black;
```
```
  border-bottom: solid 2px black;
```
```
}
```
```
 
```
```
#menu a {
```
```
  color: #111;
```
```
  .bordered;
```
```
}
```
```
 
```
```
.post a {
```
```
  color: red;
```
```
  .bordered;
```
```
}
```
Reglas anidadas, que nos permiten definir reglas siguiendo una estructura más legible y fácilmente reconocible por su paralelismo con la estructura del documento:
```
#header {
```
```
  color: black;
```
```
 
```
```
  .navigation {
```
```
    font-size: 12px;
```
```
  }
```
```
  .logo {
```
```
    width: 300px;
```
```
    :hover { text-decoration: none }
```
```
  }
```
```
}
```
Visibilidad de variables. Las variables pueden ser declaradas de forma global (como en el primer ejemplo) o asociadas a algún selector, lo que les aporta ámbito de visibilidad de forma muy similar a los lenguajes tradicionales:
```
@var: red;
```
```
 
```
```
#page {
```
```
  @var: white;
```
```
  #header {
```
```
    color: @var; // color será “white”
```
```
  }
```
```
}
```
Accesores. Less permite utilizar valores de propiedades y variables como contenido para otras propiedades de forma muy natural:
```
#defaults {
```
```
  @width: 960px;
```
```
  @color: black;
```
```
}
```
```
 
```
```
.article { color: #294366; }
```
```
 
```
```
.comment {
```
```
  width: #defaults[@width];
```
```
  color: .article['color']; 
```
```
}
```
Fijaos que el bloque #defaults no tiene por qué corresponder con un elemento del documento a formatear, se trata sólo de una forma de agrupar variables y reglas, consiguiendo un efecto empaquetador muy similar a los espacios de nombres.
Comentarios en línea, al más puro estilo C++ ó C#:
```
// Get in line!
```
```
@var: white;
```
Importación de archivos, permitiendo acceder a reglas y variables definidas en otros archivos:
```
@import "library"; // Si la extensión es .less, se puede omitir
```
```
@import "typo.css";
```

¿Y cómo funciona esto? Muy sencillo. En primer lugar, escribimos la hoja de estilos en un archivo .less, en el que podemos utilizar las características descritas anteriormente, y lo incluimos en las páginas donde nos interese, como lo hacemos siempre:

<link href="/Content/estilos.less" rel="stylesheet" type="text/css" />

Es interesante tener en cuenta que Less es compatible con CSS, lo que quiere decir que si simplemente renombramos el .css a .less, ya tendremos una hoja de partida.

A continuación, debemos introducir en el web.config una declaración que asocie la extensión .css al compilador Less:

<httpHandlers>

  <add validate="false" path="*.less" verb="*"

    type="dotless.Core.LessCssHttpHandler, dotless.Core" />

</httpHandlers>

Cuando llega una petición, el handler se encargará de compilar el archivo .less, generar el .css correspondiente y enviarlo minimizado al cliente, cacheando el resultado para posteriores usos, si se lo indicamos en la configuración, una sección opcional del web.config.

.Less está diseñado para ASP.NET 3.5 o superior, y por supuesto, es válido tanto para Webforms como para ASP.NET MVC. Se distribuye bajo licencia Apache 2.0, y está aún en fase beta, por lo que habrá que estar atento a la evolución de este interesantísimo proyecto.

Enlaces:

Publicado en: Variable not found.

Publicado ASP.NET MVC 2 Beta

2009-11-18T14:07:00.002+01:00

Hace sólo unas horas Haack ha anunciado en su blog la publicación de la versión beta del framework ASP.NET MVC 2, que tenemos a nuestra disposición tanto a nivel de código fuente como de instalador binario.

Echando un vistazo rápido a las release notes, las novedades son:

introducción de los nuevos métodos Html.RenderAction() y Html.Action(), el primero de ellos para escribir directamente la salida resultado de ejecutar la acción dada, y el segundo para obtenerla como cadena.
helpers para la generación de controles de edición en las vistas, basados en expresiones lambda o, en otras palabras, con tipado fuerte: ValidationMessageFor(), TextAreaFor(), TextBoxFor(), HiddenFor()y DropDownListFor().
mejoras en TempDataDictionary, destinadas a controlar de forma más pormenorizada la persistencia de los datos.
se incluyen las librerías de validación en cliente, MicrosoftAjax.js y MicrosoftMvcAjax.js. Para utilizar este automatismo, sólo hay que incluir ambos script en la vista (o master) e invocar al método de activación: <% Html.EnableClientValidation(); %>.
Visual Studio incorpora ahora una opción “Add Area” en el menú contextual, así como un cuadro de diálogo para crearlas.
es posible crear controladores de ejecución asíncrona heredando de la clase AsyncController. Esto permite crear acciones que se ejecuten en segundo plano, sin bloquear el hilo principal.
nueva plantilla de proyectos en blanco, es decir, sin toda la parafernalia de las plantillas actuales (páginas de ejemplo, autenticación, etc.).
capacidad para registrar múltiples proveedores de validación, permitiéndonos adoptar otras soluciones o frameworks, o crear nuestras propias opciones.
separación del proveedor de datos, el componente utilizado para obtener datos del contexto, en subcomponentes especializados en función del origen de la información (formularios, ruta, cadena de petición, y archivos). También existe la posibilidad de crear proveedores personalizados.
Y otras mejoras, de menor calado, citadas de forma concisa en las notas de la revisión, como:

adición de nuevos métodos y propiedades a la clase ModelMetadata.
cambios en la plantilla por defecto de las vistas para generar los controles utilizando los nuevos helpers.
helpers con soporte para datos binarios en el modelo, generando automáticamente campos ocultos codificados en Base64.
etc.

Y ojo, que esta beta sólo funciona con Visual Studio 2008 SP1, no podemos probarla con la última beta de Visual Studio 2010. Eso sí, puede convivir en nuestros equipos con MVC 1.0 sin interferencias.

El siguiente paso será la publicación de la RC, que está prevista “antes de finalizar el año”, aunque no se planea incluir funcionalidades nuevas, simplemente corregir bugs y pequeñas mejoras que puedan derivar de esta fase de pruebas y del feedback de los usuarios. Por tanto, en líneas generales, lo que nos trae esta beta será prácticamente lo que vendrá en la versión 2 :-)

Enlaces:

Publicado en: Variable not found.

Indicios de que tu interfaz de usuario fue creado por un programador

2009-11-16T17:17:00.006+01:00

Ya sabemos lo que suele ocurrir cuando los programadores diseñamos interfaces de usuario ;-). Para seguir profundizando en este curioso ~~e inevitable~~ fenómeno, Ian Voyce ha publicado hace unas semanas el divertido post The 7 signs your UI was created by a programmer, en el que recoge pistas que nos ayudarán a determinar si el interfaz de la aplicación que usamos a diario está creado por un diseñador experto en usabilidad, o ha sido el propio desarrollador el encargado de dichas tareas.

Bueno, en realidad se trata más bien de una lista con malos hábitos en el diseño de interfaces, y no necesariamente creados por programadores, pero ciertamente me he reconocido en alguno de los puntos y me han hecho gracia. Los cito y comento a continuación:

Iconos de exclamación en cuadros de diálogo
Efectivamente, cuando incluimos una exclamación en un cuadro de diálogo no pensamos en que es posible que el usuario vea el mensaje 50 veces al día, con lo que dejaría de ser ese mensaje asombroso y puntual que pensamos en un principio. Hoy en día, muchas aplicaciones utilizan un tono mucho más neutral y cercano para enviar mensajes al usuario.
Mensajes con dobles negaciones en cuadros de diálogo, del tipo “¿Seguro de que no quieres perder tus cambios?” -- Hmm… sí… digooo, no… También son muy propias construcciones más complejas de la cuenta, paradójicas o inesperadas, como “Su mensaje no se ha enviado, ¿desea descartarlo?”, que ponen a prueba los reflejos de cualquier usuario.
Orden de tabulación inexistente, o incorrecto, que fuerzan a que la navegación se realice exclusivamente a golpe de ratón. Y especialmente en aplicaciones de entrada masiva de información, el cambio de teclado a ratón y viceversa es terrible. Y para hacernos conscientes de ello, nada como dar vacaciones un rato al animalito y ver lo bien que manejamos determinadas aplicaciones.
Groupboxes rodeándolo todo… porque hay sitios donde queda bonito, aunque no esté agrupando nada ;-). Me confieso: durante años, he rodeado de groupboxes todo lo que se me ponía por delante, porque me parecía más agradable a la vista. Ahora lo estoy dejando ;-)
Iconos creados en el IDE, je, este es otro de mis puntos fuertes: soy un fiera diseñando iconos desde el editor de Visual Studio. El problema es que, a pesar de lo orgulloso que estoy siempre de mis creaciones artísticas, no quedan bien e incluso introducen un cierto tufillo a cutre en las aplicaciones.
Utilización de grids, debido a lo que llama Voyce “la enfermedad de considerar que Excel es lo máximo en diseño de interfaces de usuario”, que fomenta la creación de rejillas con controles de lo más potentes y variopintos en las filas de datos (calendarios, gráficos, etc.).
Message Boxes no implementados, el equivalente en los interfaces de usuario a los TODO en el código fuente :-DD. Buena analogía. Algo parecidos serían los mensajes del tipo “Este mensaje no debería aparecer nunca” que alguna vez he encontrado por ahí, auténticos actos de rebeldía contra sus respectivos creadores.
Uso excesivo de cuadros de diálogo, incluso en situaciones en las que perfectamente podríamos obviarlos por no ofrecer información útil para el usuario, que no va a poder entender, o donde no se requieren decisiones por su parte.

Esto es algo muy frecuente de ver. Por ejemplo, el otro día accediendo a una aplicación web para la que es necesario contar con certificado digital, me saltó la alerta que muestro a la derecha:

Sí, probablemente los componentes Java necesarios para la autenticación y firma electrónica hayan sido detectados con éxito, pero… ¿realmente era necesario interrumpir mi navegación para informarme de ello? ¿Un usuario, sabrá interpretar el mensaje? Y en cualquier caso, ¿le aporta algo? No sé, no sé… me da que es un alert() creado por un desarrollador durante las pruebas y que al final se quedó ahí para la posteridad.

Hasta aquí las citadas en el post original, aunque siguiendo en la misma línea, puedo añadir algunas más de propia cosecha:

Cuadros de diálogo con mensajes y botones inconsistentes. Mensajes del tipo “¿desea cancelar la operación?” en cuyo pie aparece un botón “Aceptar” y otro “Cancelar” siempre me dejan pensando un rato. Si pulso aceptar, ¿estoy aceptando la cancelación, o justo lo contrario?… Muchas veces, parece que sólo podemos confiar en el azar.
Cuadros de mensaje con demasiados (o demasiados pocos) botones. No siempre atendemos a la Ley de Hick, que nos dice que “el tiempo que se tarda en tomar una decisión aumenta a medida que se incrementa el número de alternativas”, y eso nos lleva a crear cuadros de diálogo con muchos, demasiados, botones que el usuario debe estudiar.

Y justo en el lado contrario, pero igualmente desconcertantes, son los cuadros de diálogo de introducción de datos sin ningún botón de aceptación, en los que su cierre (con la X de la esquina superior) implica el salvado de datos.
Interfaz descuidado. Y no hablo de bonito o feo, términos bastante subjetivos, sino de descuidado: controles sin alinear, con tamaños no proporcionales al contenido pretendido, sensación de desorden, faltas de ortografía… Esto no es un problema de interfaces creados por desarrolladores, sino creados por gente que no pone el más mínimo cariño en lo que hace, independientemente de su puesto de trabajo.
Interfaces monocromos, mi especialidad. Como inútil reconocido en temas de diseño, me considero absolutamente incapaz de crear algo medio aparente con más de un color (eso sí, empleando distintas tonalidades ;-)). Nunca he entendido la compleja lógica que hay detrás del “eso no pega con aquello”, que algunos/as parecen dominar de serie.
Controles con trastorno de personalidad. Un clásico es encontrar un grupo de checkboxes actuando como un grupo de radios. A ver, si sólo vamos a poder elegir una de las opciones, ¿por qué no usamos directamente el control específicamente ideado para ello? ¿Y un desplegable con las opciones "Activar" y "Desactivar"? ¿No sería más claro poner un checkbox?

Artículo original: The 7 signs your UI was created by a programmer

Publicado en: Variable not found.

Cómo obtener el valor de campos de formulario con el mismo nombre

2009-11-11T23:59:00.000+01:00

Imaginemos el siguiente código HTML:

<input type="text" name="nombre" /><br />

<input type="text" name="nombre" /><br />

Si desde un servidor ASP.NET, como respuesta a un submit (o postback en webforms), queremos acceder a los valores del campo del formulario “nombre”, podemos utilizar el clásico Request[“nombre”] para obtener los valores de todos ellos separados por comas.

Así, si introducimos en el primer campo el valor “Juan” y en el segundo “Pedro”, Request["nombre"] contendrá “Juan,Pedro”. Esto podría ser suficiente para procesarlo troceando la cadena a partir de las comas, por ejemplo así:

string[] nombres = Request["nombre"].Split(',');

string n1 = nombres[0]; // n1 = "Juan"

string n2 = nombres[1]; // n2 = "Pedro"

Sin embargo, es obvio que esta técnica genera problemas si un usuario introduce en alguno de los campos una coma, el carácter que estamos considerando como separador de los elementos.

La forma correcta de hacerlo sería utilizando el método GetValues() sobre la propiedad Form de la petición, la cual nos devuelve un array con los valores de cada campo. Por ejemplo, si en el primer campo introducimos “Juan,Jose” y en el segundo “Luis”, el resultado sería el que sigue:

string[] nombres = Request.Form.GetValues("nombre");

string n1 = nombres[0]; // Juan,Jose

string n2 = nombres[1]; // Luis

En ASP.NET MVC, el sistema de bindings es capaz de facilitarnos aún más las cosas. Si en la vista existen diferentes campos llamados “nombre”, y el submit se realiza sobre una acción en cuyos parámetros aparece un array con la misma denominación, recibiremos los datos directamente:

[AcceptVerbs(HttpVerbs.Post)]

public ActionResult Editar(string[] nombre)

    // nombre[0] -> "Juan,Jose"

    // nombre[1] -> "Luis"

Publicado en: Variable not found.

12 buenas prácticas en ASP.NET MVC

2009-11-09T00:12:00.002+01:00

Simone Chiaretta, desarrollador, MVP, bloguero y autor de un libro sobre ASP.NET MVC Framework, entre otros méritos, recoge en su recomendable bitácora Code Climber unas cuantas buenas prácticas a considerar cuando trabajamos en proyectos ASP.NET MVC, que cito y comento a continuación:

Borra el AccountController. Siendo fieles al principio YAGNI, prácticamente lo primero que deberíamos hacer al crear un proyecto ASP.NET MVC es eliminar todo lo relativo al sistema de cuentas de usuario incluido por defecto en el mismo, que muy difícilmente nos será útil tal cual en proyectos reales.
Aísla los controladores del mundo exterior, no dejes que dependan de elementos externos como HttpContext, datos del reloj (hora/fecha actual), ni accedas directamente a bases de datos o elementos de configuración. Harán tu aplicación muy poco flexible y difícil de testear.
Utiliza un contenedor IoC, te ayudará a gestionar las dependencias de los controladores, facilitando la sustitución de estos elementos de forma muy sencilla, sobre todo, vistas a la realización de pruebas.
No utilices cadenas mágicas, dificultan la detección de errores. No es buena idea usar expresiones del tipo ViewData["variable"], las vistas tipadas son el mecanismo ideal para pasar información desde el controlador. También es peligroso el uso de los helpers que utilizan cadenas para referirse a nombres de controladores y acciones, y para ello existen alternativas basadas en expresiones lambda o plantillas T4 bastante potentes.
Crea tus propias convenciones tomando como base las propuestas por el framework MVC. Por ejemplo, crea controladores y vistas base de las que heredar, e implementa en ellos aspectos comunes.
Presta atención a los Verbos, a los verbos HTTP, claro ;-). Envía información desde formularios con el método POST y genera las vistas que muestran datos desde peticiones GET. Utiliza el patrón Post-Redirect-Get.
DomainModel != ViewModel, el primero representa los datos y lógica del dominio, mientras que el segundo se diseña exclusivamente para satisfacer las necesidades de información de las vistas y normalmente serán estructuras planas, y principalmente strings, que es el tipo de datos que normalmente necesitan los controles de entrada y salida de datos.
Usa ActionFilters para manejar los datos compartidos entre distintas acciones y controladores, dejando que éstos se centren en la tarea que deben realizar. Puedes utilizar filtros para cargar información común (por ejemplo, para componentes de una página maestra) y utilizar vistas parciales para mostrarla.
No utilices el code-behind. Nunca. En mi opinión, el code-behind no es necesario (al menos no le he encontrado aún ninguna utilidad en MVC), y puede crear confusión si compartes tu código con otros desarrolladores que no esperarán encontrar nada ahí.
Escribe HTML siempre que puedas. No utilices helpers que lo único que van a hacer es generar el código HTML por ti. Es decir, mejor usar <input type="submit" value="grabar" /> que <%=Html.Submit("grabar") %>.
Si hay un if, escribe un helper. Las vistas deben ser fáciles de leer, y muchos bloques de códigos mezclados con marcado no facilita la tarea. Dado que en las vistas la lógica ha de ser necesariamente muy simple, probablemente puedas crear helpers que simplifiquen la composición del marcado en casos en los que hay condiciones if o bucles for .
Elige el motor de vistas cuidadosamente, WebFormViewEngine no es el único ni, para Simone, el mejor de los existentes. De hecho, recomienda el uso de Spark, un motor de vistas libre en el que es el propio HTML el que controla el flujo de composición del interfaz de forma muy sencilla y potente:

<viewdata products="IEnumerable[[Product]]"/>

<ul if="products.Any()">

  <li each="var p in products">${p.Name}</li>

</ul>

<else>

  <p>No products available</p>

</else>

En mi caso, todavía no he encontrado motivos suficientes como para dar el salto a un motor de vistas distinto de WebForms. Sinceramente, no me parece tan aberrante ver código y marcado dentro del mismo archivo, siempre teniendo en cuenta que la lógica que debe aparecer en estos puntos debe ser siempre relativa a la presentación y, por tanto, simplísima.

Opiniones aparte, la verdad es que es un interesante grupo de consejos a tener en cuenta.

Fuente: 12 ASP.NET MVC Best Practices

Publicado en: Variable not found.

Cadenas nulas, vacías o en blanco

2009-11-04T00:12:00.000+01:00

Encuentro en el blog de Gunnar Peipman un post sobre el nuevo método string.IsNullOrWhiteSpace, aparecido en .NET Framework 4.0 Beta 2, cuya misión es retornar un booleano indicando si la cadena pasada como parámetro contiene un nulo, está vacío, o exclusivamente caracteres de espaciado (espacios, saltos de línea, tabulaciones, etc.), un escenario bastante frecuente cuando estamos, por ejemplo, validando formularios o cualquier tipo de datos de entrada.

Por si no podemos esperar hasta la llegada de la nueva versión del framework, Gunnar propone una solución temporal basada en crear un método de extensión sobre la clase string que realice la misma tarea:

public static class StringHelper

    public static bool IsNullOrWhiteSpace(this string s)

        if (s == null)

            return true;

        return (s.Trim() == string.Empty);

Como ya comenté por aquí hace tiempo, la ventaja que tiene utilizar esta técnica es que permite invocar el método sobre una instancia de cadena, aunque ésta sea nula, sin riesgo a errores:

string a = null;

string b = "    ";

string c = "\n";

string d = "Hey!";

Console.Write (a.IsNullOrWhiteSpace()); // True

Console.Write (b.IsNullOrWhiteSpace()); // True

Console.Write (c.IsNullOrWhiteSpace()); // True

Console.Write (d.IsNullOrWhiteSpace()); // False

Y para los fieles a Visual Basic .NET, ahí va el código equivalente:

Imports System.Runtime.CompilerServices

Public Module StringHelper

    <Extension()> _

    Public Function IsNullOrWhiteSpace(ByVal s As String) As Boolean

        If s Is Nothing Then

            Return True

        End If

        Return s.Trim() = String.Empty

    End Function

End Module

Publicado en: Variable not found.

El patrón Post-Redirect-Get

2009-11-02T23:50:00.001+01:00

Hoy vamos a dedicar un rato a comentar una técnica que es considerada una buena práctica en el desarrollo de aplicaciones web: el patrón PRG o Post-Redirect-Get. Seguramente alguna vez lo haya citado por aquí, pero nunca lo había explicado en profundidad.

Por último, antes de entrar en materia, es conveniente indicar que lo que vamos a ver es válido para ASP.NET Webforms, ASP.NET MVC y, en general, para cualquier tecnología de construcción de sitios web que incluya componentes en servidor, puesto que se trata de una forma de hacer las cosas, no de la implementación de una solución. Ya en el último epígrafe veremos implementaciones concretas para Webforms y el framework MVC.

El problema

Es bastante habitual que al desarrollar aplicaciones para la web creemos un formulario de introducción de datos, y lo normal es que estos envíen los datos al servidor utilizando el verbo HTTP Post. Hasta aquí, bien.

Cuando desde el servidor se recibe una petición de este tipo normalmente se ejecuta un código, por ejemplo para almacenar la información en la base de datos y, de forma bastante frecuente, aprovechamos para enviar al cliente feedback de que su operación ha sido realizada con éxito. Y aquí es donde aparece el problema.

Si el usuario, por esas ocurrencias que suele tener ;-), decide pulsar F5 o actualizar la página en el navegador, se van a producir dos efectos desagradables:

primero, se le mostrará al usuario un cuadro de diálogo informándolo de algo que difícilmente va a entender y que, en cualquier caso, le asustará bastante. El navegador le informa de que está realizando un reenvío completo de los datos del formulario.
segundo, una vez superado el escollo anterior, se volvería a ejecutar en servidor toda la lógica asociada a la recepción de datos del formulario con consecuencias, a veces terribles, como el almacenamiento de registros duplicados en la base de datos.

¿Cómo podemos evitar esto?

La solución: Post-Redirect-Get

El patrón PRG viene a indicarnos una forma de diseñar nuestras aplicaciones pensando en evitar los problemas descritos anteriormente, y, como veremos, es bastante simple. El procedimiento general a seguir sería:

Recibimos la petición Post con los datos que ha introducido el usuario en un formulario.
Ejecutamos la lógica asociada a la recepción de dicho formulario, por ejemplo, grabar en la base de datos.
Enviamos al cliente una respuesta con código HTTP 30x (Redirect), indicando al agente de usuario que debe solicitar otra página, en la mostraremos un mensaje informando de que el proceso se ha realizado con éxito.
El navegador obtiene dicha página mediante una petición de tipo Get.

En este punto, si el usuario decide ~~(o el diablo que lleva dentro le ordena ;-))~~ refrescar la página, lo único que conseguirá será que su navegador vuelva a solicitar la página en la que le estamos informando de que el proceso ha sido satisfactorio. No se le muestra ningún cuadro de diálogo amenazante, ni se ejecuta la lógica de nuevo, ni hay ningún tipo de daños colaterales.

El siguiente diagrama, basado en el de la imprescindible Wikipedia, muestra gráficamente este proceso:

¿Un poco de código? Sí, por favor

ASP.NET WebForms

La abstracción sobre los protocolos montada por la tecnología Webforms hace más difícil reconocer los conceptos que estamos tratando, pero aún así es bastante sencillo aplicar el patrón.

En los formularios web, los postbacks se realizan a través de métodos Http POST, por lo que la implementación de la lógica y la redirección podremos realizarlas en la implementación del evento de servidor correspondiente, por ejemplo, el de pulsación de un botón:

protected void btnAceptar_Click(object sender, EventArgs e)

    if (Page.IsValid)

        // Lógica

        Cliente cliente = new Cliente(txtNombre.Text, txtApellidos.Text);

        GestorDeClientes.Salvar(cliente);

        // Redirección

        Response.Redirect("clientes.aspx", true);

La página “clientes.aspx” podría ser ser el listado de clientes registrados en el sistema, por ejemplo.

ASP.NET MVC

En el framework MVC, por su cercanía a los protocolos, sí es fácil identificar los conceptos de petición y redirecciones. El siguiente código sería equivalente al anteriormente mostrado, pero enviando al usuario a la acción “Index”:

[HandleError]

public class ClientesController : Controller

    ... // Otras acciones

    [AcceptVerbs(HttpVerbs.Post)]

    public ActionResult Editar(Cliente cliente)

        if (ModelState.IsValid)

            GestorDeClientes.Grabar(cliente);

            return RedirectToAction("Index");

        return View(cliente);

Publicado en: Variable not found

Variable not found en Facebook

2009-10-29T23:41:00.000+01:00

Antes se solía decir que si no estabas en Internet, no existías; ahora que todo el mundo está en Internet, parece ser que si no estás en las redes sociales no existes. Cosas de la evolución, supongo ;-)

Y aunque no soy muy amigo de este tipo de afirmaciones, por si acaso, en un auténtico alarde de socialización, he creado el sitio Variable not found en Facebook, que pongo a vuestra disposición para mantenernos en contacto de una forma algo más bidireccional de lo acostumbrado:

Espero que nos veamos también por allí. Y sobre todo, que incrementemos el triste número de fans que tiene hasta el momento… :-DDD

Publicado en: Variable not found.

Modifica el portapapeles de tus visitantes con ZeroClipboard

2009-10-28T22:37:00.000+01:00

Si estás creando herramientas webs que generan código o texto para que tus visitantes lo copien y peguen en otras aplicaciones, ZeroClipboard puede facilitar su utilización, al permitir introducir el contenido que deseemos en el portapapeles de los usuarios.

Hace tiempo ya comenté una forma de acceder transparentemente al portapapeles de los visitantes utilizando el objeto window.clipboardData, pero esta posibilidad desapareció, al menos en su versión silenciosa, conforme los navegadores fueron tomándose más en serio los temas de seguridad. A día de hoy, si intentamos utilizar estas funciones desde Explorer, aparece un cuadro de diálogo de confirmación algo molesto, para alertar al usuario de que el script de una página está intentando acceder a dicha información.

ZeroClipboard es una pequeña librería javascript que utiliza una película flash para acceder al portapapeles en modo “escritura”, es decir, para introducir en él un valor generado desde un script como respuesta a una acción del usuario como la pulsación de un botón o enlace. Podéis verlo en acción en esta demo online.

El siguiente código muestra cómo podemos utilizarlo. Creamos un <textarea> cuyo evento onchange aprovechamos para ir almacenando el contenido que pasará al portapapeles cuando el usuario pulse el enlace (btnCopiar) al que hemos vinculado este comportamiento:

<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>Prueba de ZeroClipboard</title>
    <script type="text/javascript" src="ZeroClipboard.js"></script>
</head>
<body>
    <textarea id="texto" rows="10" cols="10" 
              onchange="clip.setText(this.value);"></textarea>
    <br />
    <a id="btnCopiar" href="#">Copiar</a>
</body>
<script type="text/javascript">
    clip = new ZeroClipboard.Client();
    clip.glue('btnCopiar');
</script>
</html>

Si lo probáis, podréis ver que en ningún momento se alerta al usuario de que su portapapeles va a ser modificado, quedando muy limpio y profesional. :-)

Publicado en: Variable not found.

jqGrid: Grids espectaculares para ASP.NET MVC, paso a paso

2009-10-26T23:49:00.000+01:00

Dicen las malas lenguas ;-) que durante una reunión del equipo de diseño de ASP.NET MVC alguien dijo: “necesitaremos un control tipo Repeater”, refiriéndose a algún tipo de mecanismo para mostrar datos tabulados de forma sencilla. Y la respuesta del jefe técnico fue, “ya lo tenemos: se llama bucle foreach”.

Anécdotas aparte, es cierto que en ASP.NET MVC 1.0 no existe otro mecanismo que el bucle de toda la vida para mostrar datos en tablas, la típica rejilla con información sobre elementos de una colección tan habitual en nuestras aplicaciones. La máxima ayuda que tenemos “de serie” es el andamiaje generado por Visual Studio a la hora de generar una vista sobre una enumeración de elementos, que es válida únicamente en escenarios muy sencillos.

Y aquí es donde entra jQuery Grid Plugin (jqGrid para los amigos), un plugin para jQuery que se integra perfectamente con ASP.NET MVC y que permite simplificar enormemente el desarrollo de vistas de tipo grid ofreciendo al mismo tiempo unas funcionalidades espectaculares: paginación, carga de datos de forma asíncrona vía Ajax, ordenación y redimensionado de columnas, edición de celdas, interfaz multi-idioma basado en temas, y un larguísimo etcétera .

En este post vamos a implementar un grid simple de consulta de datos utilizando jqGrid 3.5 y ASP.NET MVC 1.0, paso a paso. Además, al final del post encontraréis un enlace para descargar el proyecto de demostración para Visual Studio 2008 Express.

1. Descargamos jqGrid

Lo primero, como siempre, es descargar los componentes necesarios. Para hacernos con jqGrid, es necesario visitar la página de descargas del proyecto, en la que podemos encontrar un selector que nos permitirá elegir los módulos asociados a las funcionalidades que vayamos a utilizar.

En nuestro caso, dado que vamos a implementar un escenario muy simple, seleccionaremos únicamente el módulo “Grid base” y pulsamos el botón download situado en el pie de la tabla.

La descarga es un archivo .zip bastante ligerito cuyo contenido utilizamos así:

jquery.jqGrid.min.js, que encontraréis en la carpeta “js” del archivo descargado, lo copiamos a la carpeta “scripts” del proyecto ASP.NET MVC.
grid.locale-sp.js , el archivo de localización al español que encontraremos en la carpeta “js/i18n” del .zip, lo copiamos también a la carpeta “scripts” del proyecto.
ui.jqgrid.css , disponible en la carpeta “css” del archivo comprimido, lo pasamos a la carpeta “content” del proyecto.

2. Descargamos un tema visual

jqGrid utiliza los temas visuales de jQuery UI para componer el interfaz, por lo que es necesario descargar alguno de los disponibles o bien crear uno personalizado con la herramienta on-line disponible en su página. Para nuestro ejemplo, vamos a utilizar el tema “Cupertino”.

Como en el caso anterior, seleccionamos los componentes a obtener (en principio, basta con UI Core a no ser que vayáis a utilizar esta librería para otras cosas), el tema, y pulsamos el botón download. Descargaremos un archivo .zip en cuyo interior encontramos, dentro de la carpeta “css”, una subcarpeta con el nombre del tema elegido y que copiamos a la carpeta “content” del proyecto MVC.

La imagen anterior muestra la distribución de los archivos descritos hasta el momento en las distintas carpetas en las que hay que colocarlos.

3. Incluimos los componentes en el proyecto ASP.NET MVC

Tras crear el proyecto ASP.NET MVC, vamos a incluirle ahora las referencias a librerías y archivos necesarios para poder utilizar jqGrid.

Básicamente, tendremos que incluir en las páginas donde vayamos a utilizarlo referencias a jQuery, jqGrid, el archivo de localización, la hoja de estilos utilizada por jqGrid, y el tema que estemos empleando. Lo más fácil es hacerlo a nivel de página maestra, por ejemplo así:

<head runat="server">

    <title><asp:ContentPlaceHolder ID="TitleContent" runat="server" /></title>

    <link href="../../Content/Site.css" rel="stylesheet" type="text/css" />

    <link href="../../Content/ui.jqgrid.css" rel="stylesheet" type="text/css" />

    <link href="../../Content/cupertino/jquery-ui-1.7.2.custom.css"

          rel="stylesheet" type="text/css" />

    <script src="../../Scripts/jquery-1.3.2.min.js" type="text/javascript"></script>

    <script src="../../Scripts/grid.locale-sp.js" type="text/javascript"></script>

    <script src="../../Scripts/jquery.jqGrid.min.js" type="text/javascript"></script>

</head>

Es importante incluir todos los archivos y en el orden correcto, de lo contrario el plugin no funcionará correctamente.

4. El modelo

En lugar de utilizar una base de datos, vamos a crear una simulación en memoria de un almacén de datos personales basado en la siguiente entidad:

public class Amigo

    public int Id { get; set; }

    public string Nombre { get; set; }

    public string Apellidos { get; set; }

    public DateTime FechaDeNacimiento { get; set; }

    public string Email { get; set; }

La lógica de negocio está implementada en la clase GestorDeAmigos, que incluye, además del constructor que carga los datos iniciales en el almacén (una colección de tipo List<Amigo> , los siguientes métodos:

public IEnumerable<Amigo> ObtenerAmigos(int pagina, int elementosPorPagina,

                                        Func<Amigo, IComparable> orden,

                                        Ordenacion ordenacion)

    IEnumerable<Amigo> datos;

    if (ordenacion==Ordenacion.Ascendente)

        datos = datosAmigos.OrderBy(orden);

    else

        datos = datosAmigos.OrderByDescending(orden);

    return datos.Skip((pagina - 1) * elementosPorPagina).Take(elementosPorPagina);

public int ContarAmigos()

    return datosAmigos.Count;

Del código anterior, sólo comentar los parámetros del método ObtenerAmigos:

pagina y elementosPorPagina, indican, respectivamente el número de página de datos a mostrar y el número de registros máximo a mostrar en cada una de ellas.
orden es una lambda que retorna la expresión por la cual ordenaremos los datos. Si estuviéramos utilizando consultas SQL directas o LINQ to SQL podríamos usar otros enfoques, como la construcción de queries dinámicas o Dynamic LINQ.
ordenacion indica, usando una enumeración, si el orden es ascendente o descendente.

Así, a continuación puede verse un ejemplo de lo simple que quedaría una llamada a este método, flexible pero con tipado fuerte:

var amigos = gestorDeAmigos.ObtenerAmigos(

                   1,                       // Página actual

                   25,                      // Registros por página

                   amigo=>amigo.Apellidos,  // Expresión de ordenación

                   Ordenacion.Ascendente    // Orden

);

5. El controlador

Una de las principales ventajas que ofrece jqGrid es que la carga de los datos la realiza mediante peticiones Ajax. En la práctica, esto significa que irá lanzando llamadas a una acción de nuestro controlador para solicitarle la información conforme vaya necesitando datos, por ejemplo, durante la carga inicial de la página o cuando el usuario utiliza las herramientas de paginación, enviándole los siguientes parámetros:

sidx, el índice o nombre del campo de ordenación actual.
sord, “asc” o “desc”, indicando si el orden es ascendente o descendente.
page, el número de página actual.
rows, número de elementos a obtener para completar la página.

El retorno de este método de acción debe ser un objeto serializado en JSON (aunque también permite XML) y ha de ajustarse a un formato especificado en la documentación, que es el que jqGrid espera recibir, algo como:

  total: "xxx",

  page: "yyy",

  records: "zzz",

  rows : [

    {id:"1", cell:["cell11", "cell12", "cell13"]},

    {id:"2", cell:["cell21", "cell22", "cell23"]},

...

El método de obtención de datos, nuestra acción, seguirá normalmente el patrón recogido en el código mostrado a continuación. Si os fijáis, lo único que estamos haciendo es reproducir fielmente esta estructura anterior en un objeto anónimo, de forma que al transformarlo en JSON (gracias al retorno de tipo JsonResult) se genere justo lo que necesitamos:

public ActionResult ObtenerDatosGrid(string sidx, string sord, int page, int rows)

    var datos = [...]          // Obtener datos del modelo

    var totalRegistros = [...] // Contar todos los registros

    int totalPages = (int)Math.Ceiling((decimal)totalRegistros / (decimal)rows);

    var data = new

        total = totalPages,        // Total de páginas

        page = page,               // Página actual

        records = totalRegistros,  // Total de registros (obtenido del modelo)

        rows = from a in datos     // Datos de filas

               select new {

                   id = a.Id,                // ID único de la fila

                   cell = new string[] {     // Array de celdas de la fila

                       a.Apellidos,                             // Primera columna,

                       a.Nombre,                                // Segunda columna,

                       a.FechaDeNacimiento.ToShortDateString(), // Tercera columna,

                       a.Email                                  // Cuarta columna

};

    return Json(data);

Nuestro ejemplo se ajusta totalmente al patrón anterior, aunque incluiremos código extra para tener en cuenta las ordenaciones indicadas por los parámetros sidx y sord en la invocación al modelo. Observad cómo construimos las expresiones de ordenación:

public ActionResult ObtenerDatosGrid(string sidx, string sord, int page, int rows)

    // Establecemos la función de ordenación dependiendo del valor del

    // parámetro "sidx", que es el campo de orden actual

    Func<Amigo, IComparable> funcOrden =

        sidx == "Apellidos" ? a => a.Apellidos :

        sidx == "FechaDeNacimiento" ? a => a.FechaDeNacimiento :

        sidx == "Email" ? a => a.Email :

        (Func<Amigo, IComparable>)(a => a.Id);

    // Establecemos si se trata de orden ascendente o descendente, en

    // función del parámetro "sord", que puede valer "asc" o "desc"

    Ordenacion ordenacion = sord == "asc" ? Ordenacion.Ascendente : Ordenacion.Descendente;

    // Usamos el modelo para obtener los datos

    var datos = gestorDeAmigos.ObtenerAmigos(page, rows, funcOrden, ordenacion);

    int totalRegistros = gestorDeAmigos.ContarAmigos();

...

6. La vista

En la vista debemos crear un elemento contenedor, concretamente una tabla XHTML con un identificador único que después usaremos para indicarle al plugin dónde tiene que actuar su magia. Si además, como bastante habitual, pensamos incluir herramientas de paginación, tendremos que incluir también un contenedor para la misma:

<table id="list"></table>

<div id="pager"></div>

El siguiente paso es inicializar jqGrid cuando se termine de cargar la página, para lo que crearemos un código javascript como el mostrado a continuación, en el que se invoca la función de activación del plugin sobre la tabla cuyo ID se indica en el selector (“#list“), y especificando el comportamiento deseado en los parámetros que le siguen:

script type="text/javascript">

    jQuery(document).ready(function() {

        jQuery("#list").jqGrid({

            url: '<%= Url.Action("ObtenerDatosGrid") %>',

            datatype: 'json',

            mtype: 'GET',

            colNames: ['Apellidos', 'Nombre', 'Fecha Nac.', 'Email'],

            colModel: [

              { index: 'Apellidos', width: 150, align: 'left' },

              { index: 'Nombre', width: 150, align: 'left', sortable: false },

              { index: 'FechaDeNacimiento', width: 80, align: 'center' },

              { index: "Email", width: 120, align: 'left'}],

            pager: jQuery('#pager'),

            rowNum: 20,

            rowList: [20, 50, 100],

            sortname: 'Apellidos',

            sortorder: 'asc',

            viewrecords: true,

            imgpath: '/content/cupertino/images',

            caption: 'Agenda personal',

            height: 400,

            width: 900,

            onSelectRow: function(id) {

                alert("Pulsado Id: " + id);

});

});

</script>

Revisamos rápidamente el significado de los distintos parámetros:

url, la dirección de la acción que suministrará los datos.
datatype, que indica el formato de intercambio de datos.
mtype , el verbo HTTP (get o post) que se utilizará para las peticiones.
colnames, un array con los títulos de las columnas.
colmodel, un array en el que cada elemento es un objeto que define
- index: el nombre del campo que recibiremos en el método de acción indicando la ordenación actual.
- width: el ancho, en píxeles.
- align: alineación de la columna.
- sortable: si la columna se puede utilizar como criterio de ordenación.
pager, el elemento sobre el que se compondrá la herramienta de paginación.
rownum, número de elementos por página.
rowlist, elementos por página mostrados en un desplegable para que el usuario lo ajuste.
sortname, el campo de ordenación por defecto.
sortorder, si la ordenación por defecto es ascendente o descendente.
viewrecords, si se muestra el total de registros en la herramienta de paginación.
imgpath , ruta hacia la carpeta de imágenes del tema elegido.
caption, el título del grid.
height, width, alto y ancho del grid, en píxeles.
onSelectRow, función anónima ejecutada cuando el usuario selecciona una fila. Recibe como parámetro el identificador único del registro.

Y… ¡Voilá!

¡Hasta aquí hemos llegado! Hemos visto cómo utilizar el magnífico jqGrid en un escenario simple, paso a paso, comenzando por la descarga de los componentes, preparando el proyecto para poder utilizarlos y, finalmente, implementando el modelo, el controlador, y la vista.

Pero jqGrid no es sólo eso, ni mucho menos. No hemos visto más que la punta del iceberg: el plugin permite realizar búsquedas, edición, anidación de grids, árboles, escenarios maestro-detalle… en fin, una maravilla.

jqGrid se distribuye bajo licencia dual GPL y MIT, y puede ser utilizado tanto en proyectos comerciales como libres. Dispone de una documentación bastante razonable, y muchos ejemplos para que podamos apreciar sus virtudes.

Descargar proyecto de demostración:

Publicado en: Variable not found.

Ilities

2009-10-20T01:23:00.001+02:00

Los “ilities”, cuya traducción a nuestro idioma podría ser algo así como “ilidades”, son atributos que definen aspectos no funcionales y normalmente asociados con requisitos técnicos y cualidades de un sistema o componente software. El nombre viene del sufijo –ilidad, que, como podréis ver a continuación, es común a la práctica totalidad de ellos.

He encontrado en la Wikipedia una interesante (aunque no exhaustiva) relación ilidades, que podemos utilizar a la hora de intentar transmitir las características de un sistema… o simplemente para aparentar ser auténticos expertos en una reunión de trabajo ;-)

Accesibilidad, es decir, el hecho ser accesible a muchas personas, con independencia de sus características, dispositivos utilizados, etc.
Reportabilidad, capacidad para monitorizar y registrar las acciones del usuario.
Exactitud, grado de distancia desde los resultados ofrecidos por un sistema a los valores entendidos como reales.
Adaptabilidad, facilidad que presenta un software para ser adaptado a necesidades concretas.
Administrabilidad, indica la capacidad de un sistema o componente para ser administrado y gestionado.
Asequibilidad, que indica que, atendiendo a su coste, el sistema puede ser adquirido o conseguido por los clientes.
Auditabilidad, transparencia frente a sistemas de auditoría.
Disponibilidad, grado en el que un sistema está disponible, operativo y funcional.
Credibilidad, que es considerado subjetiva y objetivamente como una fuente de información fiable.
Conformidad con estándares, grado de cercanía a las prácticas o técnicas aceptadas como estándares.
Compatibilidad, que funciona en un escenario determinado, o permite sustituir otros sistemas equivalentes.
Componibilidad, capacidad para combinar el software con otros elementos para componer sistemas no previstos inicialmente.
Configurabilidad, esto es, que dispone de mecanismos que permiten configurar algunos aspectos de su comportamiento.
Corrección, que indica que el software actúa conforme a sus especificaciones.
Personalizabilidad, capacidad de un sistema para ser personalizado a las preferencias de sus usuarios.
Degradabilidad, capacidad para mantener las funcionalidades básicas en condiciones adversas.
Demostrabilidad, aplicable a aquellos sistemas cuyo funcionamiento puede ser demostrado.
Dependabilidad, que define la probabilidad de que el sistema complete su misión, dado que estaba disponible en el comienzo de la misma.
Desplegabilidad, capacidad de un software para ser desplegado en un escenario.
Distribuibilidad, capacidad o facilidad de un componente o sistema para ser distribuido.
Durabilidad, mantenimiento de las funciones con el paso del tiempo.
Efectividad, o capacidad para lograr el efecto deseado.
Eficiencia, capacidad para lograr el efecto deseado con el menor consumo posible de recursos.
Evolucionabilidad, grado de facilidad con la que es posible hacer evolucionar un sistema para adaptarse a nuevas condiciones.
Extensibilidad, capacidad de un software para ser ampliado con nuevas funciones sin modificar su estructura básica.
Fidelidad, que ofrece precisión y confianza en la representación de la realidad.
Flexibilidad, que puede adaptarse con facilidad a cambios en el entorno.
Instalabilidad, facilidad para ser instalado en un entorno determinado.
Integridad, capacidad para evitar y sobreponerse a errores en la información que maneja.
Intercambiabilidad, que indica que un componente puede ser sustituido por otro sin modificar aquellos que lo utilizan.
Interoperabilidad, capacidad que tiene un sistema para intercambiar información con otro.
Aprendibilidad, es decir, la capacidad que presenta un software para enseñar su propio manejo al usuario.
Mantenibilidad, o facilidad con la que se puede corregir, modificar o ampliar un software.
Gestionabilidad, facilidad para gestionar la complejidad de un sistema.
Movilidad, posibilidad que tiene un sistema de funcionar en distintas ubicaciones geográficas.
Modularidad, grado en el que un software está internamente dividido en bloques independientes.
Nomadicidad, capacidad de un sistema para adaptarse de forma transparente a una situación de desconexión por cambio de ubicación-
Operabilidad, capacidad de un software para funcionar y cumplir su misión.
Portabilidad, la facilidad con la que un software puede ser transferido a otro entorno software o hardware.
Precisión, nivel de detalle con el que un sistema es capaz de manejar información.
Predictibilidad, grado de certeza del comportamiento del sistema ante un escenario determinado.
Recuperabilidad, capacidad de un sistema de restablecer un nivel apropiado de servicio y recuperar sus datos en caso de producirse fallos.
Fiabilidad, es la habilidad de un software para realizar sus funciones de forma correcta bajo unas condiciones determinadas.
Repetibilidad, es la capacidad de generar el mismo resultado si no cambian las condiciones.
Reproducibilidad, es el grado de precisión que se obtiene al intentar reproducir un comportamiento del sistema.
Responsividad, velocidad con la que un sistema realiza una tarea, por ejemplo responder a la entrada del usuario.
Reusabilidad, facilidad con la que un componente o sistema puede ser reutilizado para añadir funcionalidades o características en un nuevo sistema.
Robustez, capacidad para continuar la operación aún en el caso de producirse errores inesperados.
Seguridad, capacidad de un software para conseguir niveles aceptables de daños a personas, negocios, software, propiedades o entorno.
Escalabilidad, facilidad con la que un sistema puede ser adaptado para satisfacer necesidades mayores de carga de trabajo.
Uniformidad, grado de presentación como una estructura consistente, aunque el sistema incluya diversas tecnologías.
Soportabilidad, que hace referencia a la habilidad del soporte técnico para dar soporte a los productos.
Asegurabilidad, capacidad para asegurar distintos niveles de un sistema.
Simplicidad, o ausencia de complicaciones y dificultades.
Estabilidad, capacidad de un software para funcionar períodos del tiempo sin parar o funcionar incorrectamente.
Comprobabilidad, el grado en el que un componente soporta la realización de pruebas para validar su corrección.
Oportunidad, es decir, el hecho de estar disponible en el momento en el que debe estarlo.
Ubicuidad, capacidad de un software para estar presente en todas partes, en cualquier momento.
Comprensibilidad, facilidad con la que un software puede ser comprendido a los distintos niveles.
Usabilidad, facilidad con la que un usuario puede utilizar un sistema software para conseguir un objetivo.

Los términos originales estaban en inglés y algunos no eran fácilmente traducibles, así que en más de una ocasión he tenido que echar mano de la creatividad y patear a la RAE y todos sus integrantes ;-D

Publicado en: Variable not found.

En la onda, con Google Wave

2009-10-14T13:00:00.001+02:00

No recuerdo cuándo exactamente, debió ser cuando estuve comentando la presentación de esa misteriosa criatura llamada Google Wave, pero al parecer solicité una invitación para probar el producto, y hoy me ha llegado.

Tras seguir el enlace recibido por email, he instalado Chrome Frame, el complemento para Internet Explorer que permite incrustar el navegador Chrome, y ya se puede decir que estoy en la onda ;-)

A ver si un día de estos tengo un rato libre para probarlo en profundidad, por que la verdad es que tengo ganas de comprobar de primera mano si el revuelo que ha levantado Wave en la red está fundado o no. Seguiremos informando al respecto. :-)

Por cierto, tengo ocho invitaciones para otros tantos amigos que quieran probarlo, sólo tenéis que hacerme llegar vuestra dirección de correo electrónico e iré enviando las invitaciones en riguroso orden de llegada.

Uf, ya sólo tengo siete, vais a tener que daros prisa…

Actualizado (15-oct): ya he informado a los afortunados por email, y enviado sus datos a Google Wave, sólo les queda esperar a que les lleguen las invitaciones. Gracias a todos por participar.

Publicado en: Variable not found.

xVal, validaciones automáticas para ASP.NET MVC

2009-10-12T23:58:00.002+02:00

Mientras esperamos impacientes la llegada de ASP.NET MVC 2 con su flamante sistema integrado de validación de datos en cliente y servidor, xVal puede sernos de bastante utilidad al ofrecernos prácticamente las mismas funciones previstas para la versión 2, y alguna más :-)

xVal es un framework para aplicaciones ASP.NET MVC 1.0 (y superiores) creado por Steve Sanderson , y presentado en sociedad el pasado 17 de septiembre, que permite validar la información almacenada en clases del modelo, tanto en el lado cliente como en servidor, de forma automatizada.

Su diseño es muy flexible, permitiéndonos elegir entre distintos marcos de trabajo para la validación en servidor (de serie soporta los atributos DataAnnotations, Castle Validator y NHibernate Validator, aunque se pueden crear proveedores personalizados) y librerías en cliente (inicialmente utiliza el magnífico plugin jQuery Validation).

Vamos a ver, paso a paso, cómo podemos comenzar a utilizarlo de forma inmediata en nuestras aplicaciones ASP.NET MVC 1.0, utilizando las restricciones DataAnnotations y la librería de validación para jQuery citada anteriormente.

1. Preparamos la infraestructura

En primer lugar, vamos a preparar el entorno para utilizar el framework de validación:

Descargamos xVal desde CodePlex. Se distribuye en un fichero .zip que incluye tanto el ensamblado como archivos de soporte, así que lo descomprimimos en cualquier parte para tener los archivos a mano.

Descargamos el plugin de validación de jQuery, por ejemplo, desde el CDN de Microsoft (¿qué es el Microsoft Ajax CDN?) y lo incluimos en la carpeta /scripts de nuestro proyecto. Otra posibilidad sería no descargarlo y referenciarlo directamente nuestras páginas, a gusto del consumidor ;-)

Añadimos a la carpeta /scripts del proyecto la librería xVal.jQuery.Validate.js presente en el raíz del comprimido de xVal. Este archivo, junto con el anterior, son imprescindibles para montar la validación automática en el lado cliente que veremos más adelante. Además, para que los mensajes aparezcan en nuestro idioma, copiamos también al mismo sitio el archivo xVal.Messages.es-ES.js, disponible en la carpeta “internationalization” del zip.

Copiamos al directorio /bin de nuestra aplicación el ensamblado xVal.dll, o simplemente añadimos una referencia en el proyecto hacia dicho archivo, que encontraréis en el raíz del fichero comprimido que hemos descargado en primer lugar.

Retocamos ligeramente el Web.config de nuestro proyecto para que sea incluido automáticamente el espacio de nombres xVal.Html en nuestras vistas, facilitando así el acceso a los helpers suministrados:
```
<system.web>
```
```
  <pages>
```
```
     <namespaces>
```
```
        
```
```
        <add namespace="xVal.Html"/>
```
```
    </namespaces>
```
```
  </pages>
```
```
</system.web>
```

Los pasos comentados hasta el momento son genéricos, es decir, tendremos que realizarlos en todos los proyectos en los que vayamos a utilizar este framework de validación. Podría ser interesante, por tanto, crearnos una plantilla de proyecto en la que tengamos ya todo este trabajo realizado.

2. Definimos las restricciones con Data Annotations

Ahora vamos a definir, de forma declarativa, las restricciones que queremos imponer a las propiedades de las clases del modelo, utilizando los atributos denominado data annotations, distribuidos con .NET 3.5 y originalmente diseñados para trabajar con la tecnología Dynamic Data.

Dado que vamos a declarar las restricciones utilizando los atributos data annotations, hay que añadir referencia en el proyecto a System.ComponentModel.DataAnnotations.

A continuación, tenemos que incluir en el proyecto un método que nos permita recorrer las anotaciones de las clases, ejecutarlas e ir generando los errores apropiadamente. Este método lo utilizaremos más adelante, desde los componentes del Modelo, para comprobar si los valores presentes en las propiedades cumplen los requisitos impuestos por el dominio del sistema.

El código es muy sencillo, el propio Sanderson nos facilita uno en el proyecto de demostración de xVal, que podéis copiar y pegar:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using xVal.ServerSide;

using System.ComponentModel.DataAnnotations;

using System.ComponentModel;

namespace MyProject.Validation

 public static class DataAnnotationsValidationRunner

  public static IEnumerable<ErrorInfo> GetErrors(object instance)

    var metadataAttrib = instance.GetType()

                            .GetCustomAttributes(typeof(MetadataTypeAttribute), true)

                            .OfType<MetadataTypeAttribute>().FirstOrDefault();

    var buddyClassOrModelClass = metadataAttrib != null ?

                                    metadataAttrib.MetadataClassType:

                                    instance.GetType();

    var buddyClassProperties = TypeDescriptor.GetProperties(buddyClassOrModelClass)

                            .Cast<PropertyDescriptor>();

    var modelClassProperties = TypeDescriptor.GetProperties(instance.GetType())

                            .Cast<PropertyDescriptor>();

    return from buddyProp in buddyClassProperties

               join modelProp in modelClassProperties on buddyProp.Name equals modelProp.Name

               from attribute in buddyProp.Attributes.OfType<ValidationAttribute>()

               where !attribute.IsValid(modelProp.GetValue(instance))

               select new ErrorInfo(

                            buddyProp.Name,

                            attribute.FormatErrorMessage(string.Empty), instance);

Ojo, esto sólo tenemos que hacerlo cuando estemos utilizando DataAnnotations, como es el caso; si utilizamos otros frameworks como el de Castle o NHibernate no será necesario, puesto que incluyen ya implementaciones para realizar esta tarea.

Marcamos las propiedades de la entidad del modelo con las restricciones a aplicar durante la validación. Podemos utilizar los atributos disponibles para restringir los valores permitidos en cada propiedad como Required , StringLength , Range y otros (puedes ver la relación completa aquí).

Un ejemplo podría ser el siguiente, en el que vemos varias restricciones aplicadas a las propiedades de la entidad:
```
public class Recluta
```
```
{
```
```
    [Required, StringLength(30)]
```
```
    public string Nombre { get; set; }
```
```
 
```
```
    [Required, StringLength(40)]
```
```
    public string Apellidos { get; set; }
```
```
 
```
```
    [Required, Range(1, 4)]
```
```
    public int Talla { get; set; }
```
```
 
```
```
    [Required, DataType(DataType.Date)]
```
```
    public DateTime FechaNacimiento { get; set; }
```
```
}
```
Sin embargo, muchos os preguntaréis qué ocurre cuando estas entidades de datos las generamos con herramientas automáticas, como el diseñador de Entity Framework. En estos casos, cada vez que generemos el modelo, las clases serían machacadas por las nuevas versiones, y nuestras anotaciones pasarían a mejor vida.

Afortunadamente, existe la posibilidad de declarar una clase paralela (o, como la llaman, ‘buddy class’), en la que definiremos exclusivamente las propiedades a las que queremos añadir alguna anotación. Además, marcaremos la entidad original (aprovechando que la mayoría de estas herramientas automáticas las generan como parciales) indicando la clase que contiene los metadatos asociados a ésta:
```
// Indicamos en la entidad original que los
```
```
// metadatos se encuentran en 'ReclutaMedata'
```
```
[MetadataType(typeof(ReclutaMetadata))]
```
```
public partial class Recluta
```
```
{ 
```
```
    // Nada más que añadir aquí
```
```
}
```
```
 
```
```
// Definimos los metadatos para la entidad 'Recluta'
```
```
public class ReclutaMetadata
```
```
{
```
```
    [Required, StringLength(30)]
```
```
    public string Nombre { get; set; }
```
```
 
```
```
    [Required, StringLength(40)]
```
```
    public string Apellidos { get; set; }
```
```
 
```
```
    [Required, Range(1, 4)]
```
```
    public int Talla { get; set; }
```
```
 
```
```
    [Required, DataType(DataType.Date)]
```
```
    public DateTime FechaNacimiento { get; set; }
```
```
}
```
Como podéis observar, la entidad y la clase de metadatos son prácticamente iguales. Un poco anti-DRY sí que es, pero bueno.

3. Validamos en servidor

La propuesta de xVal para el lado del servidor consiste en desplazar la lógica de validación al modelo, dado que es éste el que normalmente impone las restricciones en los datos que han de estar presentes en las entidades del dominio. Una forma de realizarlo sería así:

por cada entidad, creamos un método que valide la información del mismo, primero invocando al ValidationRunner (el proceso de validación basado en anotaciones descrito anteriormente), y luego añadiendo aquellas reglas de negocio no incluidas en dichas anotaciones). Un ejemplo podría ser el siguiente:
```
private void validar(Recluta recluta)
```
```
{
```
```
    var errors = DataAnnotationsValidationRunner.GetErrors(recluta);
```
```
    if (errors.Any())
```
```
        throw new RulesException(errors);
```
```
 
```
```
    // Regla de negocio adicional: prohibido alistarse reclutas
```
```
    // con hermanos en el cuartel...
```
```
    if (tieneHermanos(recluta.Apellidos))
```
```
    {
```
```
        throw new RulesException("Apellidos",
```
```
                    "El recluta tiene hermanos ya alistados", recluta);
```
```
    }
```
```
}
```
Este método podría incluirse en la propia entidad Recluta, o bien donde se implemente la lógica de negocio asociada a la misma.

En cualquier caso, como se puede observar, cuando se producen errores debido a un incumplimiento de las restricciones indicadas en las anotaciones, se lanza una excepción de tipo RulesException (facilitada por xVal) que contiene una descripción de los problemas encontrados. Asimismo, la existencia de otro tipo de problemas, hallados de forma programática, son lanzados también en una excepción del mismo tipo.

antes de realizar operaciones susceptibles de modificar el estado del sistema, tenemos que asegurarnos de que las entidades son válidas. Observad, por ejemplo, la implementación del método que nos permite añadir un recluta al sistema:
```
public void Crear(Recluta recluta)
```
```
{
```
```
    validar(recluta);
```
```
    reclutas.Add(recluta);
```
```
}
```
Si se producen errores en la validación, el método Crear() será interrumpido por la excepción RulesException lanzada desde validar(), y llegará finalmente hasta el Controlador, donde deberá ser procesada.

desde el punto de vista del Controlador, podremos comprobar que el patrón a seguir es realmente sencillo, pues toda la lógica de validación la hemos desplazado al modelo.

El siguiente código muestra los métodos de acción asociados a la creación de una entidad; el primero de ellos simplemente se encarga de mostrar la vista de edición sobre un objeto recién creado, mientras que el segundo obtiene los datos del recluta desde el formulario, e intenta realizar la operación de creación sobre el modelo:
```
public ActionResult Create()
```
```
{
```
```
    return View(new Recluta());
```
```
}
```
```
 
```
```
[AcceptVerbs(HttpVerbs.Post)]
```
```
public ActionResult Create(Recluta recluta)
```
```
{
```
```
    try
```
```
    {
```
```
        gestorDeReclutas.Crear(recluta);
```
```
    }
```
```
    catch (RulesException ex)
```
```
    {
```
```
        ex.AddModelStateErrors(this.ModelState, "");
```
```
    }
```
```
    if (!ModelState.IsValid)
```
```
        return View(recluta);
```
```
    else 
```
```
        return RedirectToAction("Index");
```
```
}
```
Como se puede observar, se capturan las excepciones de validación que se produzcan al realizar el alta, añadiendo al ModelState los errores que se estén informando en éstas y, en función de la validez de los datos, enviando al usuario a la vista correspondiente.

Y esto es todo. Con estas operaciones, ya tenemos las validaciones listas en el lado del servidor, pasemos ahora a solucionarlas en cliente.

4. Validamos en el cliente

Está claro que la validación en el lado del servidor es la que única que debemos hacer obligatoriamente; el lado cliente es sensible al equipo del usuario, que puede estar accediendo desde dispositivos sin javascript (o con esta característica desactivada), o incluso puede ser fácilmente manipulado, por lo que no podemos confiar en que los datos lleguen ya siendo válidos.

Sin embargo, ofrecer validación en cliente es una característica imprescindible hoy en día vistas a realizar interfaces muy usables, capaces de ofrecer al usuario feedback inmediato sobre sus acciones.

Con xVal, añadir en este punto validaciones en cliente es realmente sencillo, pues ya tenemos realizado prácticamente todo el trabajo, quedando simplemente:

incluir las librerías script en las vistas donde vayamos a realizar la edición de las entidades del modelo. Si vamos a utilizarlas en muchos sitios, lo más fácil es añadirlas a la página maestra:

<script src="../../Scripts/jquery-1.3.2.min.js" type="text/javascript"></script>

<script src="../../Scripts/jquery.validate.min.js" type="text/javascript"></script>

<script src="../../Scripts/xVal.jquery.validate.js" type="text/javascript"></script>

<script src="../../Scripts/xVal.Messages.es-ES.js" type="text/javascript"></script>

generar en la vista los scripts de validación de las entidades que nos interesen. En el siguiente código generamos la lógica para la entidad Recluta:
```
<%= Html.ClientSideValidation<MiProyecto.Models.Recluta>() %>
```

5. ¡Y hasta aquí hemos llegado!

A lo largo de este post hemos recorrido los pasos necesarios para echar a andar el framework xVal en una aplicación ASP.NET MVC 1.0.

Faltan muchos aspectos por comentar, como la posibilidad de utilizar validaciones Ajax en servidor, permitir la localización en decimales, escribir nuestros propios atributos de anotaciones, etc., pero creo que este post ya es lo suficientemente extenso… ya lo veremos en otra ocasión.

Puedes descargar el proyecto de demostración desde Skydrive:

Publicado en: Variable not found.

Grabación y materiales de la charla sobre MVC

2009-10-07T17:04:00.001+02:00

Pues eso, que ya están disponibles para su descarga tanto la grabación del evento como los materiales utilizados durante la charla de ayer, organizada por Second Nug, en la que realizamos una introducción al framework ASP.NET MVC.

En los materiales se incluye tanto el PPT utilizado en la primera parte de la presentación como el código del proyecto que desarrollamos durante la segunda parte, el famoso sistema Aúpa!net ;-), en forma de solución para Visual Web Developer Express 2008 (SP1). Recordad que para poder ejecutarlo y jugar con él necesitáis instalar previamente ASP.NET MVC 1.0.

Gracias a todos los que pudisteis asistir al evento en directo (y en especial, los que aguantasteis hasta el final como auténticos campeones ;-)) … bueno, y a los que asistiréis aunque sea off-line ;-P

Enlaces:

	Acceder a la grabación del evento
	Descarga de materiales (.zip)

Publicado en: Variable not found.

Recordatorio: mañana, ¡a por ASP.NET MVC!

2009-10-05T13:23:00.000+02:00

Sólo recordaros que mañana martes 6, a las 19:30 (GMT+2), estaré charlando sobre ASP.NET MVC en el evento on-line organizado por Second Nug.

Durante las dos horas de duración previstas veremos cómo crear una aplicación web completa con esta tecnología alternativa a Webforms, mientras vamos comentando técnicas, detalles y aspectos a tener en cuenta al desarrollar con ASP.NET MVC.

Nos os la perdáis, eh?! ;-)

Enlaces:

Registrarse como asistente al evento
Descarga del software Office Live Meeting (requerido para asistir)
Otros eventos de desarrollo de Second Nug

Publicado en: Variable not found

Publicada la segunda preview de ASP.NET MVC 2

2009-10-02T11:32:00.000+02:00

Ayer mismo anunciaba Phil Haack la publicación de la segunda preview de ASP.NET MVC 2, que continúa profundizando en las mejoras que ya se incluyeron en la primera entrega.

Según se recoge en el documento de notas del producto , las novedades que podremos encontrar son:

Abstracción del proveedor de metadatos, que será útil para implementar nuestros propios sistemas de obtención de metainformación sobre las clases del modelo, aunque por defecto se utilizarán los atributos presentes en System.ComponentModel.DataAnnotations.
Abstracción del proveedor de validaciones del modelo, que nos permitirá utilizar mecanismos personalizados de validación durante el proceso de binding, que por defecto utilizará también las DataAnnotations.
Validación automática en cliente, que aunque permite la utilización de otros frameworks, la implementación por defecto utiliza el plugin jQuery Validation para generar en cliente la lógica de validación descrita en los metadatos de las propiedades del modelo. De momento, soporta las siguientes DataAnnotations:
- StringLengthAttribute, para limitar el tamaño máximo de un campo texto.
- RequiredAttribute, para indicar la obligatoriedad de introducir un valor.
- RegexAttribute, que añade la restricción de obligado cumplimiento de la expresión regular indicada.
- RangeAttribute, para especificar el rango de valores de un campo (por ejemplo, un entero).
Dado que el model binder implementa las validaciones en servidor, parece que vamos en camino para ahorrarnos el trabajo sucio :-)
Inclusión del filtro RequireHttpsAttribute, que aplicado a una acción, fuerza a que ésta sea invocada utilizando el protocolo HTTPS.
Inclusión del helper Html HttpMethodOverride, que permite sobrescribir el verbo HTTP enviado por el cliente en aquellos agentes de usuario que no soportan los verbos menos frecuentes (PUT, DELETE…), introduciendo un campo oculto que es detectado posteriormente.
Posibilidad de incluir áreas en un proyecto único, es decir, sin necesidad de crear proyectos independientes, facilitando además el registro de las mismas.
El atributo HiddenInputAttribute permite ahora especificar propiedades del modelo que deben ser renderizadas en cliente con un campo hidden.
Y otras mejoras, de las que selecciono sólo algunas:
- Controller.Execute() lanzará una excepción cuando sea llamado más de una vez en la misma instancia. Dado que una instancia del controlador debe atender exclusivamente a una petición, es una medida que ayuda a prevenir problemas con contenedores IoC configurados para generar singletons, por ejemplo.
- Inclusión de nuevos verbos HTTP, como PUT o DELETE para facilitar la creación de sistemas REST.
- Soporte para el tipo de datos DataType.Password, haciendo que se rendericen como cuadros de edición de tipo password las propiedades que sean marcadas con este atributo.
- Se ha establecido como editor para los booleanos anulables un desplegable con las opciones “No especificado”, “Sí” y “No”.
- Mejoras de eficiencia, introduciendo una caché de expresiones compiladas para los helpers que utilizan sintaxis lambda fuertemente tipada.
- (Podéis ver el resto en el documento de notas del producto).

De momento todavía no funciona con la beta de Visual Studio 2010, sólo con las versiones 2008 convenientemente servicepackeadas.

Enlaces:

Publicado en: Variable not found.

Charla en Second Nug sobre ASP.NET MVC

2009-09-28T21:10:00.002+02:00

Los chicos de Second Nug han tenido la amabilidad de invitarme a dar una charla sobre ASP.NET MVC el próximo martes 6 de octubre, de 19:30 a 21:30 horas, hora peninsular (GMT+2). Y obviamente, no podía rechazar la oportunidad de hablar un rato sobre esta tecnología de desarrollo de aplicaciones web que tanto me gusta. :-)

Como otros eventos organizados por el grupo, se trata de un Webcast, la asistencia es gratuita y el aforo ilimitado; sólo necesitáis registraros en el sitio web de Microsoft y estar el día de autos frente a un ordenador con conexión a Internet, el software gratuito Live Meeting, y una gran bolsa de palomitas. Dado que el principal objetivo de la sesión será mostrar los conceptos básicos del desarrollo con ASP.NET MVC, no es necesario que contéis con conocimientos previos sobre dicho framework.

La charla será estructurada como entiendo que deben hacerse estas cosas: poca teoría y mucha acción. Primero describiré algo de la filosofía y principios fundamentales, y seguidamente pasaremos a desarrollar una aplicación completa partiendo desde cero (Archivo>Nuevo>Proyecto), aprovechando cada funcionalidad para comentar técnicas y detalles a tener en cuenta al desarrollar con este marco de trabajo.

Espero veros por allí, paso lista ;-)

Enlaces:

Eventos de desarrollo de Second Nug
Registrarse como asistente al evento
Descarga del software Office Live Meeting (requerido para asistir)

Publicado en: Variable not found

Eliminar los encabezados X-AspNet* de las respuestas en ASP.NET MVC (y ASP.NET)

2009-09-23T23:58:00.000+02:00

Si observamos las respuestas enviadas al cliente que solicita una página de un sitio web creado con el framework MVC, veremos que, además de los encabezados HTTP estándar, el sistema añade información sobre las versiones de ASP.NET y del propio framework MVC que estamos utilizando:

Esta información, además de consumir ancho de banda (poco, todo hay que decirlo, pero nada despreciable en sitios con tráfico muy alto), aportan información que posibles atacantes podrían utilizar para sacar provecho a vulnerabilidades conocidas de estos productos. En mi opinión, lo mejor es mostrar los menores detalles posibles al respecto.

Si queremos eliminar la pista correspondiente a la versión de ASP.NET sobre la que corre el sistema (X-AspNet-Version), bastaría con introducir en el web.config la siguiente declaración:

<configuration>

    <system.web>

        <httpRuntime enableVersionHeader="false" />

    </system.web>

</configuration>

Para eliminar, además, la información sobre la versión de ASP.NET MVC framework en ejecución (X-AspNetMvc-Version), tendremos que introducir el siguiente código para que se ejecute durante la inicialización de la aplicación, en el global.asax, indicando así que deseamos deshabilitar el envío de este encabezado:

protected void Application_Start()

    [...] // Otro código de inicialización

    MvcHandler.DisableMvcResponseHeader = true;

Y con eso basta. El resultado, el que sigue:

Publicado en: Variable not found.

Fluent NHibernate 1.0 publicado

2009-09-21T01:12:00.001+02:00

A finales del agosto, James Gregory anunció la publicación de la versión 1.0 de Fluent NHibernate, una librería que ofrece una ágil alternativa a los espesos archivos de configuración de NHibernate.

Su API permite configurar desde el código de una aplicación, de forma fluida la mayoría de las veces, los mapeos entre la estructura de una base de datos relacional y el modelo de objetos que utiliza. Así, evitaremos la manipulación de grandes archivos XML, a la vez que podremos beneficiarnos de la validación en tiempo de compilación y, por supuesto, de posibilidades como la refactorización y el intellisense durante el desarrollo.

El siguiente código muestra el mapeo de la entidad Cat con sus propiedades, algunas de ellas con restricciones, y relaciones con otras entidades a uno (References) y a varios (HasMany); el nombre de la tabla y campos en el modelo relacional es el mismo que el de las propiedades, gracias a la convención sobre configuración, lo que permite simplificar código respecto a su equivalente XML:

public class CatMap : ClassMap<Cat>

  public CatMap()

    Id(x => x.Id);

    Map(x => x.Name)

      .Length(16)

      .Not.Nullable();

    Map(x => x.Sex);

    References(x => x.Mate);

    HasMany(x => x.Kittens);

Como podemos observar, el equivalente XML es mucho más verboso:

<?xml version="1.0" encoding="utf-8" ?>

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"

  namespace="QuickStart" assembly="QuickStart">

  <class name="Cat" table="Cat">

    <id name="Id">

      <generator class="identity" />

    </id>

    <property name="Name">

      <column name="Name" length="16" not-null="true" />

    </property>

    <property name="Sex" />

    <many-to-one name="Mate" />

    <bag name="Kittens">

      <key column="mother_id" />

        <one-to-many class="Cat" />

      </bag>

  </class>

</hibernate-mapping>

Otra de las ventajas que aporta es el auto-mapping , que hace utilización intensiva del principio de convención sobre configuración para generar de forma automática mapeos de aquellas entidades que atiendan a unas normas preestablecidas (aunque modificables). El siguiente código muestra la forma tan sencilla de crear los mapeos de todas las entidades definidas en el espacio de nombres MiApp.Entidades, dentro del ensamblado donde se definió la entidad Producto:

var autoMappings = AutoMap.AssemblyOf<Producto>()

  .Where(t => t.Namespace == "MiApp.Entidades");

Además del mapeo objeto-relacional, el software abarca también la configuración del acceso a datos de NHibernate a través de su interfaz de programación. El siguiente código muestra la inicialización de la conexión a una base de datos SQL Server 2005, tomando la cadena de conexión del AppSettings y mapeando automáticamente las entidades que se encuentren definidas en un namespace concreto:

var sessionFactory = Fluently.Configure()

    .Database(MsSqlConfiguration.MsSql2005

      .ConnectionString(c => c.FromAppSetting("connectionString"))

    .Mappings(m => m.AutoMappings.Add(

      AutoMap.AssemblyOf<Producto>(type => type.Namspace.EndsWith("Entidades"))))

  .BuildSessionFactory();

Y por último, hay otra característica muy interesante vistas a la realización de pruebas unitarias sobre los mecanismos de persistencia. El código mostrado a continuación crea una instancia de la clase Empleado, la inserta en la base de datos, realiza una lectura de la entidad y la compara con la original, de forma automática:

[Test]

public void EmpleadoMapeaCorrectamente()

    new PersistenceSpecification<Empleado>(session)

        .CheckProperty(emp => emp.Id, 1)

        .CheckProperty(emp => emp.Nombre, "José")

        .CheckProperty(emp => emp.Apellidos, "Aguilar")

        .VerifyTheMappings();

Más información en la wiki del proyecto . Y las descargas, desde aquí .

Publicado en: Variable not found.

Más javascript en la red: Microsoft Ajax CDN

2009-09-16T17:36:00.000+02:00

Hace unos meses comentaba la posibilidad de utilizar la infraestructura de Google para alojar las librerías javascript de nuestras aplicaciones. Pues bien, ahora es Microsoft la que ha lanzado un servicio similar, Microsoft Ajax CDN , una red de distribución de contenidos desde donde podemos descargar en tiempo de ejecución las librerías de scripts que utilicemos en nuestras aplicaciones.

O en otras palabras, que podemos hacer uso de forma gratuita de estas librerías, sin limitación de ancho de banda e independientemente de si es para fines comerciales o no. Basta con referenciarlas desde nuestro código:

<script src="http://ajax.microsoft.com/ajax/jquery-1.3.2.min.js" 
        type="text/javascript"></script>

La principal ventaja que ofrece este método es la velocidad con la que estos archivos serán servidos, puesto que se usa la infraestructura del gigante de Redmon, a la vez que se comparte la caché con otros sitios web que también las estén utilizando. También brinda la posibilidad de utilizar scripting a sitios web que no disponen de permisos para subir archivos (como la plataforma blogger)

A diferencia del servicio de Google, desde esta CDN sólo podemos encontrar de momento las librerías que oficialmente forman parte de la plataforma de desarrollo de Microsoft, como las propias de ASP.NET Ajax, jQuery y aquellos plugins que vayan añadiéndose. En la dirección http://www.asp.net/ajax/cdn/ pueden consultarse la lista completa de librerías, con sus correspondientes direcciones de descarga.

Adicionalmente, Scott Guthrie comentaba en su blog que el nuevo control ScriptManager que vendrá con ASP.NET 4.0 incluye una propiedad llamada EnableCdn que permitirá activar la descarga de las librerías Ajax y todas aquellas necesarias para el funcionamiento de controles, directamente desde sus servidores.

Los inconvenientes, pues los mismos que los del servicio de Google: si no disponemos de conexión a la red en tiempo de desarrollo, podemos tenerlo realmente crudo.

Más información en: www.asp.net/ajax/cdn

Publicado en: Variable not found.

Inicializar a null propiedades sin tipo

2009-09-15T23:59:00.001+02:00

No es algo que ocurra muy frecuentemente, pero en determinadas ocasiones puede ser útil inicializar una propiedad de un tipo anónimo con el valor nulo, por ejemplo:

var conductor = new { Nombre = ”Marisa”, Edad = 34, Auto = “Renault Megane” };

var peaton = new { Nombre = “Juan”, Edad = 43, Auto = null };

En el código anterior se entiende que lo que queremos indicar estableciendo la propiedad Auto a null es que la persona que estamos representando no dispone de automóvil, o bien no conocemos este dato.

Algo muy normal… sino fuera porque el compilador se empeña en abofetearnos con el siguiente error:

Cannot assign <null> to anonymous type property

Y la verdad, en cuanto lo pensamos un poco, tiene sentido. En los casos anteriores, se está instanciando un tipo anónimo cuyas propiedades son generadas en tiempo de compilación. En el caso anterior, el compilador crearía para el tipo anónimo una propiedad “Nombre” de tipo string, una “Edad” de tipo integer, y una “Auto”, de tipo… ¿qué tipo podría asignar el compilador a esta propiedad? Ese es precisamente el problema.

Lo mismo ocurre al intentar inicializar variables implícitamente tipadas con el valor nulo; aunque cambia el error, el concepto idéntico, el compilador no es capaz de inferir el tipo de la variable:

var persona = null; // Error: Cannot assign <null> to an implicitly-typed local variable

La forma de solucionarlo en ambos casos es muy sencilla: basta con informar explícitamente al compilador del tipo de la propiedad, para que pueda crearla sin problema, por ejemplo así:

var peaton = new { Nombre = "Juan", Edad = 43, Auto = (string)null };

var persona = null as Persona;

Publicado en: Variable not found

¿Comprometidos o involucrados?

2009-09-13T23:58:00.000+02:00

Juan Palacio, en su genial Navegápolis, publicó semanas atrás unos buenos materiales de un Curso de Scrum en los que he podido recordar una historieta que encontré hace tiempo sobre la diferencia entre la implicación y el compromiso en la realización de un proyecto:

Aunque esta metáfora se utiliza en Scrum para agrupar los roles principales distinguiendo entre aquellos que ponen “la carne en el asador” (cerdos), y el resto de afectados y participantes (gallinas), es igualmente aplicable a las actitudes de los componentes de un equipo de trabajo, independientemente de la metodología utilizada.

Publicado en: Variable not found.

Linq para NHibernate, versión 1.0

2009-09-09T21:18:00.000+02:00

Hace unas semanas, Oren Eini (o Ayende Raihen, como se le suele conocer) comunicaba la liberación de la versión 1.0 del proveedor de Linq para NHibernate, una característica altamente demandada por los usuarios desde la aparición del lenguaje de consulta integrado en .NET.

Aunque será incluido como parte del producto NHibernate en versiones venideras, han decidido liberar la actual release del proveedor como paquete independiente para que pueda comenzar a utilizarse desde este momento. Está siendo testado en multitud de aplicaciones en producción desde hace varios años, y al parecer el funcionamiento es más que correcto.

¿Y cómo puede ayudarte este proveedor, si eres usuario de NHibernate? El siguiente ejemplo, tomado de Caffeinated Coder muestra cómo una consulta a base de datos puede simplificarse y hacerse mucho más legible utilizando Linq, además de beneficiarse del tipado fuerte, intellisense y comprobaciones en tiempo de compilación:

Utilizando el API de NHibernate:

public IList<Call> GetCallsByDate(DateTime beginDate, int interpreterId)

    ICriteria criteria = Session.CreateCriteria(typeof(Call))

        .CreateAlias("Customer", "Customer")

        .Add(Restrictions.Gt("StartTime", beginDate))

        .Add(

            Restrictions.Or(

                Restrictions.Lt("EndTime", DateTime.Now), Restrictions.IsNull("EndTime"))

        .Add(Restrictions.Eq("Interpreter.Id", interpreterId))

        .AddOrder(Order.Desc("StartTime"))

        .AddOrder(Order.Desc("Customer.Name"));

        return criteria.List<Call>() as List<Call>;

Utilizando Linq:

public IList<Call> GetCallsByDateWithLinq(DateTime beginDate, int interpreterId)

    var query = from call in Session.Linq<Call>()

        where call.StartTime > beginDate

            && (call.EndTime == null || call.EndTime < DateTime.Now )

            && call.Interpreter.Id == interpreterId

        orderby call.StartTime descending, call.Customer.Name

        select call;

    return query.ToList();

Podéis descargar tanto los binarios como el código fuente desde la página del proyecto en SourceForge.

Publicado en: Variable not found.

Posters sobre ASP.NET MVC

2009-09-07T22:28:00.000+02:00

BB&D a través de su iniciativa DRP ha incluido en su ya extenso repositorio de posters que abarcan innumerables temáticas (arquitectura, modelado, desarrollo, sistemas operativos, etc.), cuatro chuletas sobre ASP.NET MVC a las que vale la pena echarles un vistazo:

	ASP.NET MVC Framework Cheat Sheet Información genérica sobre el framework, que incluye la estructura de carpetas de los proyectos de este tipo, la sintaxis del mapeo de rutas, un diagrama del patrón MVC y el ciclo de vida de las peticiones.
	ASP.NET MVC Controller Cheat Sheet Muestra los diferentes tipos de ActionResult disponibles, una relación de atributos con sus usos (filtros, selectores de acciones y enlaces de datos), reglas para la definición de métodos de acción
	ASP.NET MVC View Cheat Sheet Referencia rápida de los helpers `Html` y `Url`, las directivas de declaración de vistas, y las distintas formas de enviar contenidos al cliente.
	ASP.NET MVC Proven Practices Contiene algunos consejos y buenas prácticas al desarrollar una aplicación con el framework.

Así que ya sabéis, si todavía os queda espacio en la pared y necesitáis tener a mano una referencia rápida de ASP.NET MVC, id preparando impresora y chinchetas ;-)

Publicado en: Variable not found