ASP.NET MVC. ModelBinderProvider para Tipos Genéricos (y II). KeyValuePair Data Binding

Descargar código de ejemplo
Códigos de muestra - Ejemplos MSDN. ModelBinderProvider para tipos genéricos

Artículos anteriores:
ASP.NET MVC. ModelBinderProvider para Tipos Genéricos (I). Creando el escenario

En el artículo anterior vimos cómo MVC no es capaz de realizar de forma automática el enlace de datos para elementos de tipo KeyValuePair.

ASP.NET MVC trata de utilizar el ModelBinder configurado por defecto, el DefaultModelBinder, para realizar el enlace de datos. La forma de actuar con tipos complejos es siempre la misma: intenta crear una instancia del elemento buscando e invocando un constructor sin argumentos y, a continuación, trata de asignar valores a cada una de sus propiedades.

En el caso de KeyValuePair el tipo sí que tiene un constructor sin argumentos por lo que el DefaultModelBinder será capaz de crear la instancia del elemento, sin embargo las propiedades Key y Value son de sólo lectura, por lo que no será capaz de asignar los valores a las propiedades.

En este artículo veremos cómo realizar el enlace de datos para este tipo de datos.

ASP.NET MVC. ModelBinderProvider para Tipos Genéricos (I). Creando el escenario

Descargar código de ejemplo
Códigos de muestra - Ejemplos MSDN. ModelBinderProvider para tipos genéricos

En un post anterior mostré cómo podíamos crear y registrar un ModelBinder personalizado en una aplicación MVC (ASP.NET MVC. Crear un ModelBinder personalizado). Sin embargo, el tipo de datos que indicamos a MVC a la hora de registrar el ModelBinder debe ser un tipo de datos específico, no podemos indicar un tipo genérico.

Entonces, ¿cómo podemos crear un ModelBinder para un tipo de datos genérico que ASP.NET MVC no es capaz de enlazar por defecto?

Por suerte ASP.NET MVC nos permite también la opción de registrar proveedores de ModelBinders o ModelBinderProviders los cuales se encargan de crear las instancias de ModelBinders para ciertos tipos de datos.

En este artículo mostraré cómo crear y registrar un ModelBinderProvider para el tipo genérico KeyValuePair<TKey, TValue>. Veremos porqué ASP.NET MVC no es capaz de enlazarlo por defecto, cómo crear el ModelBinder para el tipo y cómo podemos indicarle a MVC que debe utilizar nuestro ModelBinder para enlazar estos tipos de datos utilizando un ModelBinderProvider.

ASP.NET MVC. Crear un ModelBinder personalizado.

Una de las herramientas más útiles de las que disponemos en ASP.NET MVC es el data binding o enlace de datos, que se encarga de transformar de manera automática los datos recibidos del navegador a los tipos de datos usados en los argumentos de las acciones de nuestros controladores.

Sin embargo el proceso de binding que realiza por defecto MVC se nos puede quedar corto cuando utilizamos tipos de datos complejos.

En este artículo voy a mostrar cómo podemos indicarle a MVC cómo debe realizar el enlace de datos con un tipo de datos predeterminado a través de la implementación de un ModelBinder.

El código completo tanto en C# como en Visual Basic .NET está disponible en:

Códigos de muestra - Ejemplos MSDN. Crear un Model Binder personalizado

ASP.NET MVC. htmlAttributes en los métodos Editor y EditorFor

En muchos de los métodos de extensión de la clase HtmlHelper de ASP.NET MVC podemos encontrar un parámetro htmlAttributes que nos permite indicar valores a atributos HTML adicionales a incluir en el código HTML generado por el método.

Estos parámetros suelen aceptar un objeto IDictionary<string,object> en los que la clave de cada elemento representa el nombre del atributo y el valor del elemento representa el valor del atributo, o un objeto en el que el nombre de sus propiedades se corresponden con los nombres de los atributos y el valor de éstas con el valor de los atributos.

Sin embargo hay dos métodos de gran uso, y en los que resultaría extremadamente útil, en los que no se incluye en ninguna de sus sobrecargas: los métodos Editor y EditorFor.

ASP.NET MVC. ModelValidatorProvider personalizado (y II) - Implementando el Proveedor

Artículo anterior:
ASP.NET MVC. ModelValidatorProvider personalizado (I) - Creando el proyecto de prueba

Tras crear el proyecto de prueba en este artículo vamos a ver cómo crear un proveedor de validadores personalizado de forma que podamos incluir validaciones en función del usuario autenticado en la aplicación.

ASP.NET MVC. ModelValidatorProvider personalizado (I) - Creando el proyecto de prueba

El espacio de nombres System.ComponentModel.DataAnnotations nos proporciona diferentes atributos de validación con los que decorar las clases y propiedades del modelo. Estos atributos son interpretados por el framework de ASP.NET MVC para aplicar estas validaciones en nuestros controladores y vistas.

Sin embargo existen ocasiones en que estas validaciones no podemos definirlas de manera estática en la definición del modelo porque dependen de otras variables. Por ejemplo, ¿cómo definimos el rango de valores aceptados por un campo importe si el importe máximo depende del usuario que esté realizando la operación?

Por suerte la extensibilidad del framework de ASP.NET MVC nos permite crear nuestro propio proveedor de validaciones en el que podemos tener en cuenta circunstancias como ésta.

ASP.NET MVC. Personalizar el Motor de Vistas de MVC (y IV). Generando las salida HTML de vistas personalizadas.

Este artículo es continuación de:
ASP.NET MVC. Personalizar el Motor de Vistas de MVC (I). Creando el escenario.
ASP.NET MVC. Personalizar el Motor de Vistas de MVC (II). Comprendiendo las vistas de MVC.
ASP.NET MVC. Personalizar el Motor de Vistas de MVC (III). Creando y registrando el motor de vistas.

En los artículos precedentes hemos visto cómo crear y registrar un motor de vistas personalizado para gestionar vistas en un formato propio. Sin embargo aún nos quedaba un último paso: la generación del código HTML para generar el formulario a partir de la vista de forma que se integre con MVC y sus características de validación y enlace de datos.

ASP.NET MVC. Personalizar el Motor de Vistas de MVC (III). Creando y registrando el motor de vistas.

Este artículo es continuación de:
ASP.NET MVC. Personalizar el Motor de Vistas de MVC (I). Creando el escenario.
ASP.NET MVC. Personalizar el Motor de Vistas de MVC (II). Comprendiendo las vistas de MVC.

En los anteriores artículos creamos un escenario en el que generábamos vistas en un formato xml personalizado y tratamos de comprender la forma en que el Framework de ASP.NET MVC gestiona las vistas.

En este artículo mostraré cómo crear y registrar el motor de vistas para gestionar estas vistas en formato xml.

ASP.NET MVC. Personalizar el Motor de Vistas (View Engine) de MVC (II). Comprendiendo las vistas de MVC.

Este artículo es continuación de:
ASP.NET MVC. Personalizar el Motor de Vistas de MVC (I). Creando el escenario.

En el anterior artículo creamos un escenario con un formato de vistas xml en el que nos resultaría útil crear un motor de vistas personalizado. En este artículo voy a mostrar cómo crear y registrar el motor de vistas que generará las páginas de la aplicación a partir del formato de vistas personalizado.

ASP.NET MVC. Personalizar el Motor de Vistas de MVC (I). Creando el escenario.

El Framework de ASP.NET MVC incorpora el motor de vistas Razor, el cual proporciona un formato de vistas muy flexible y potente. Sin embargo existen escenarios en los que puede resultar compleja definir nuestras vistas utilizando Razor.

Por suerte ASP.NET MVC está diseñado expresamente para permitir una gran flexibilidad y extensibilidad y, para estos casos, nos permite crear nuestro propio motor de vistas.

En esta serie de artículos voy a mostrar cómo podemos desarrollar nuestro propio motor de vistas integrado con el Framework de ASP.NET MVC.

ASP.NET MVC. Obtener el código generado por una vista Razor cshtml/vbhtml

El motor de vistas de Razor traduce las vistas escritas en sintaxis Razor a clases con código en C# o VB.NET y a continuación las compila. Este es el motivo por el que resulta tan sencillo incluir fragmentos de código en C# o VB.NET en las vistas.

En ocasiones puede resultar útil analizar el código de estas clases, bien para localizar errores, bien para comprender cómo funcionan estas vistas. Sin embargo puede resultar complicado localizar los archivos en los que el motor de vistas Razor genera este código. Vamos a ver cómo podemos encontrarlos de manera sencilla.

ASP.NET MVC. Gestión de Scripts en Plantillas y Vistas Parciales

En este artículo mostraré cómo podemos gestionar los scripts de plantillas y vistas parciales sin cargar código de más en páginas que no lo necesitan ni repetir código en páginas que muestran varias veces una misma plantilla.

ASP.NET MVC. Plantilla de editor para fecha y hora

En este artículo voy a mostrar cómo crear en un proyecto MVC un editor personalizado para los tipos de datos de fecha y fecha y hora. El editor se basa en el plugin DateTimePicker de jQuery.

ASP.NET. Localizando Data Annotations (y III) - Personalizar Atributos de Validación

Este artículo es continuación de:
ASP.NET. Localizando Data Annotations (I) - Archivos de recursos
ASP.NET. Localizando Data Annotations (II) - Utilizar una plantilla T4 para conectar a cualquier origen

Ya hemos visto cómo adaptar nuestros textos de los atributos de validación al idioma del usuario a través de archivos de recursos o a través de una plantilla de texto T4, mediante la cual conseguíamos independizar la gestión de nuestros textos del origen de datos utilizado. Sin embargo esta última solución también tiene sus pegas.

Por un lado están los problemas inherentes a las plantillas de texto T4. Hemos creado una plantilla T4 que, compilándose en tiempo de diseño, generaba una nueva clase. Es código que genera código, código al fin y al cabo. Pero código difícil de mantener, depurar y testear.

Por otro lado, lo que estamos haciendo en realidad, es crear una clase con información redundante para poder emular el funcionamiento de los archivos de recursos. Esto nos obliga a tener sincronizada nuestra nueva clase con el origen de datos de los textos. Cuando añadamos o eliminemos textos de nuestro origen de datos deberemos recompilar nuestra aplicación y, lo que es más importante, para compilar nuestra aplicación deberemos tener nuestro entorno de desarrollo conectado a un origen de datos con los textos completamente actualizados.

ASP.NET. Localizando Data Annotations (II) - Utilizar una plantilla T4 para conectar a cualquier origen

Este artículo es continuación de:
ASP.NET. Localizando Data Annotations (I) - Archivos de recursos

En la última entrada mostré cómo utilizar archivos de recursos para mostrar los mensajes de los atributos del namespace Data Annotations en función del idioma del usuario.

Pero ¿qué sucede si tenemos los textos de nuestra aplicación en otro lugar, por ejemplo en una base de datos?

En este ejemplo mostraré cómo podemos utilizar una plantilla de texto T4 para obtener los textos a partir de cualquier origen de datos.

ASP.NET. Localizando Data Annotations (I) - Archivos de recursos

El espacio de nombres System.ComponentModel.DataAnnotations proporciona clases de atributos que se usan para definir los metadatos para ASP.NET MVC y los controles de ASP.NET.

Estos atributos nos permiten especificar las cadenas a utilizar en la interfaz de la aplicación cuando se hace referencia al campo, se detectan errores de validación, etc. Esto resulta muy útil para tener definidas estas cadenas en un único lugar de la aplicación y que los mensajes al usuario sean uniformes a lo largo de toda nuestra aplicación.

Sin embargo, en este mundo cada vez más globalizado, cada vez son menos las aplicaciones cuyo interfaz se define en un único idioma. Entonces, ¿cómo utilizamos los atributos del namespace DataAnnotations de forma que nuestros textos se adapten al idioma del usuario?

ASP.NET MVC. RedirectToAction propagando el QueryString

En ocasiones nos podemos encontrar con en una acción de redirección necesitamos pasar valores recibidos en el QueryString a la acción destino. Si los posibles parámetros son pocos y claramente definidos podemos hacerlo a través del parámetro routeValues. ¿Pero qué pasa si los posibles parámetros son muchos o, peor aún, indefinidos?

He leído algún comentario por parte del equipo de desarrollo de MVC indicando que es una problemática a la que tienen pensado dar solución en futuras versiones. Pero, ¿qué se puede hacer mientras tanto?