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
A finales del pasado mes de Julio, Haack, Scottgu, y un sinfín de figurillas más, anunciaron la publicación del código fuente e instaladores de la primera preview de la nueva versión de la plataforma ASP.NET MVC.
Tal y como se describe en el Roadmap del producto, el objetivo de la versión 2 es aumentar la productividad de los desarrolladores que trabajen con el framework, así como cubrir determinadas necesidades muy comunes y que no llegaron a introducirse en la primera versión del producto, como las siguientes.
Soporte para “áreas”
Las áreas son subproyectos independientes con rutas, vistas y controladores que implementan una sección específica de las funcionalidades de un sistema de forma muy aislada y reutilizable. Ejemplos directos serían un sistema de foros, o un motor de blogs; implementados como áreas, una solución web que necesitara incluir dichas funcionalidades simplemente debería referenciarlas y realizar pequeños ajustes para, a partir de ese momento, poder contar con ellas.
La limpieza del enfoque adoptado favorece la organización, reutilización, el trabajo en equipo y, además, seguro que provoca la aparición de muchos componentes complejos, tanto comerciales como libres, distribuidos de esta forma y listos para ser incluidos en nuestras aplicaciones de forma sencilla.
En cualquier caso, esta primera preview incluye soporte aún muy básico para las áreas, y para utilizarlas hay que tocar a mano los archivos de proyectos (hay un paso a paso en MSDN que describe cómo hacerlo) . Ya en futuras revisiones se irá introduciendo en el IDE las herramientas para gestionarlas, así como nuevas posibilidades para su integración en un proyecto único.
Nuevo conjunto de helpers de interfaz de usuario
Métodos utilizables desde las vistas que seguro que nos harán la vida más fácil al utilizar tipado fuerte para vincular controles de edición y visualización de información a propiedades del modelo, además de permitir el diseño de plantillas para tipos de datos específicos.
En la versión 1 de ASP.NET MVC:
<%= Html.TextBox("Nombre", Model.Nombre) %> En la versión 2:
<%= Html.EditorFor(persona=>persona.Nombre) %>
Fijaos que desaparecen los nombres mágicos (constantes entrecomilladas) necesarios en la versión 1 para generar los controles de edición, y pasan a ser expresiones lambda que referencian directamente a la propiedad del modelo, por lo que se podría comprobar su corrección en tiempo de compilación.
Pero Html.EditorFor() no sólo es aplicable a tipos “nativos”, también pueden ser estructuras complejas (por ejemplo, la clase Persona), para las que generará por defecto los controles de edición de todas sus propiedades, salvo aquellas en las que se haya indicado expresamente lo contrario. Esto, que en escenarios simples puede resultar suficiente para crear formularios de edición de datos, se realizaría haciendo que la lambda devuelva el propio objeto del modelo:
<% using (Html.BeginForm()) { %><%= Html.EditorFor(persona=>persona) %>
<input type="submit" value="Enviar" />
<% } %>
Internamente, Html.EditorFor() buscará antes de renderizar ningún resultado HTML si existe una plantilla de edición para el tipo de datos devuelto por la lambda en la carpeta Views\Shared\EditorTemplates, con el nombre NombreDelTipo.ascx (por ejemplo Persona.ascx). También es posible indicarle explícitamente la plantilla que debe usar para renderizar el editor, tanto en el momento de invocar al helper como a nivel de la propia clase del modelo.
Todo lo dicho hasta ahora es válido para la visualización de datos, que utilizará el helper Html.DisplayFor(): de la misma forma, los parámetros fuertemente tipados del método nos ayudarán a detectar errores en fase de compilación, y existe igualmente la posibilidad de definir las plantillas, aunque la carpeta donde se habrán de colocar debe ser en esta ocasión Views\Shared\DisplayTemplates. Hay un buen paso a paso, aunque en inglés, de cómo utilizar este tipo de plantillas.
Un último helper más, LabelFor(), está especialmente creado para generar etiquetas asociadas a controles de edición. Su principal particularidad es que es capaz de tomar la descripción del campo desde los metadatos de la clase del modelo. Esta técnica es la misma que utiliza otra de las grandes novedades de esta versión, el sistema de validación.
Mecanismo de validación integrado
Ese gran ausente en la primera versión del framework MVC que hacía que tuviéramos que encargarnos a mano de comprobar uno por uno los datos de entrada (o utilizar frameworks externos) para que no se colara en el modelo información inválida. La solución viene de mano de las Data Annotations, un conjunto de atributos que podemos aplicar a las entidades de datos para indicar restricciones aplicables a sus valores:
public class Persona
{ [DisplayName("Nombre")] [Required(ErrorMessage = "El nombre es obligatorio!")][StringLength(45)]
public string Nombre { get; set; }
[DisplayName("Número de hijos")][Range(0, 15)]
public int NumeroDeHijos { get; set; }
}
En el ejemplo anterior vemos un caso simple en el hemos añadido metadatos a la clase del modelo que describen las particularidades de cada propiedad. ASP.NET MVC Framework versión 2 es capaz de obtener esta información y utilizarla para validar la entrada de datos al recibir un formulario, o incluso en cliente por obra y gracia de un plugin para jQuery que será incluido en la plantilla, aunque esto todavía no está disponible en esta preview.
Un detalle interesante a tener en cuenta es que, dado que las clases de datos son habitualmente generadas por herramientas automáticas, estos los metadatos pueden ser definidos en clases paralelas (clases ‘buddy’). Una solución un poco anti-DRY, pero bueno…
Otras mejoras
Hay otras mejoras de menor calado aunque también interesantes, como la inclusión del nuevo atributo [HttpPost] para acelerar la declaración de acciones restringidas a ese método del protocolo, el soporte para valores por defecto en parámetros (basado en atributos hasta que llegue el nuevo C# 4.0, aunque ya disponible en VB), o algunos cambios en el API (algunos de ellos “rompedores”). Todos estos detalles pueden consultarse en el documento de notas de la revisión.
Si quieres ir probando en persona las novedades, puedes descargar la preview y jugar con ella desde Visual Studio 2008 SP1 (también funciona para Visual Web Developer Express 2008 SP1, el IDE gratuito) sin peligro alguno. El instalable en ningún momento sobrescribe librerías o componentes de la versión 1.0, sólo creará un nuevo juego de plantillas para esta versión. Eso sí, si eres de los afortunados que están ya exprimiendo la beta 1 de VS2010, has de saber que no son compatibles, tendrás que esperar hasta la beta 2, la cual ya incluirá la próxima preview del framework.
Seguiremos atentos a la evolución del framework, que estos muchachos están que no paran…
Publicado en: Variable not found.
Pues sí… todo lo que empieza acaba, y las vacaciones no iban a ser una alegre excepción.
Aquí estamos de nuevo listos para entrar en combate. Esta vez, además, el retorno al MundoReal™ coindice con un momento de emocionantes cambios a nivel profesional, lo cual hace especialmente motivador el regreso.
En cuanto a las vas vacaciones, simplemente geniales: mucho descanso en las playas de Huelva y Cádiz y, sobre todo, un grato recuerdo de la visita a Lanzarote, que sin duda es espectacular; si alguna vez tenéis oportunidad de visitar la isla, no dudéis en ir a disfrutar de ese lugar tan diferente. La única pega ha sido la insistente ola de calor que nos ha perseguido a todos nuestros destinos, pero bueno, son gajes del oficio.
El libro está editado en español por Anaya Multimedia, bajo el nombre Struts 2; aunque, como suele ocurrir en este tipo de textos, de vez en cuando te encuentras errores de traducción y contenidos, cumple bastante bien su cometido.
Y sin más preámbulos, comenzamos la temporada 2009-10 en Variable not found, donde espero seguir contando, como hasta ahora, con vuestra participación y apoyo.
Publicado en: Variable not found.
Tras un año duro (¡muy duro!), llegan de nuevo las vacaciones: tiempo de descansar un poco, disfrutar con la familia, formatearse mentalmente y recargar las pilas con vistas a comenzar un nuevo periodo tras el verano. Y todo ello alternando entre Sanlúcar de Barrameda, El Portil, y una escapada a Lanzarote que seguro que será una delicia. No me puedo quejar, la verdad.
Variable Not Found quedará, una vez más, a la deriva hasta que regrese dentro de unas semanas. Además, para evitar que los spammers se vengan a vivir aquí, desactivaré temporalmente el envío de comentarios anónimos, lamento las molestias que pueda causar.
Feliz verano, amigos. :-)
Publicado en: Variable not found.
En la plataforma .NET existen distintas formas de hacer que una llamada a un método sea omitida bajo determinadas circunstancias. Por ejemplo, los métodos parciales permiten, en C# 3.0 y VB 9.0, que el compilador omita la llamada a funciones no implementadas. También existe la posibilidad de utilizar las clásicas directivas (como #if… #endif ) para incluir código cuando existan constantes de compilación.
Es menos conocida, sin embargo, la existencia del atributo ConditionalAttribute, que aplicado a un método hace que las llamadas a éste no sean incluidas en el ensamblado si no existe la constante de compilación cuyo nombre se indica en el parámetro.
Por ejemplo, explorando un poco el espacio de nombres System.Diagnostics, vemos que todos los métodos de la clase Debug, están adornados por este atributo así:
1: [Conditional("DEBUG")]
2: public static void WriteLine(string message)
3: { 4: TraceInternal.WriteLine(message); 5: }Ahora, imaginad que tenemos un código que usa esta clase, por ejemplo de la siguiente manera:
1: public static void Main(string[] args)
2: {3: for(int i=0; i < 1000; i++)
4: {5: Debug.WriteLine("Iteración " + i);
6: ProcesaAlgoComplejo(i);7: int j = ProcesaOtraCosa(i);
8: Debug.WriteLine("Obtenido " + j);
9: // ...
10: } 11: }Si compilamos en modo “debug” (o simplemente está definida la constante de compilación con dicho nombre), las llamadas a estos métodos serán omitidas en el ensamblado resultante, por lo que el código finalmente generado será totalmente equivalente a:
1: public static void Main(string[] args)
2: {3: for(int i=0; i < 1000; i++)
4: { 5: ProcesaAlgoComplejo(i);6: int j = ProcesaOtraCosa(i);
7: // ...
8: } 9: }Pero ojo, que se omiten tanto las llamadas al método como la evaluación de sus parámetros, y esto puede provocar errores difíciles de detectar. Por ejemplo, el siguiente código daría lugar a un bucle infinito de los de toda la vida ;-) si compilamos en modo “release”; sin embargo, compilando en “debug” funcionaría correctamente:
1: int j = 0;
2: while (j < 100)
3: {4: Console.WriteLine("Hey " + j);
5: Debug.WriteLine("Procesado " + (j++)); // <-- Esta línea desaparece cuando
6: // compilamos en modo release!
7: }Aunque en el anterior ejemplo estamos jugando con la constante predefinida DEBUG, este atributo podemos utilizarlo con otras constantes, tanto existentes como personalizadas. Como muestra, podéis echar un vistazo a la definición de la clase System.Diagnostics.Trace, que vincula el uso de sus métodos a la existencia de la constante TRACE:
1: public sealed class Trace
2: { 3: // ...
4: 5: private Trace();
6: [Conditional("TRACE")]
7: public static void Assert(bool condition);
8: [Conditional("TRACE")]
9: public static void Assert(bool condition, string message);
10: [Conditional("TRACE")]
11: public static void Assert(bool condition, string message, string detailMessage);
12: [Conditional("TRACE")]
13: public static void Close();
14: [Conditional("TRACE")]
15: public static void Fail(string message);
16: [Conditional("TRACE")]
17: public static void Fail(string message, string detailMessage);
18: [Conditional("TRACE")]
19: public static void Flush();
20: [Conditional("TRACE")]
21: 22: //...
23: }Si vais a utilizar el atributo sobre vuestros métodos, condicionándolos a la existencia de constantes de compilación personalizadas, recordad que las constantes podéis definirlas:
- desde las propiedades del proyecto en el IDE
- en la línea de comandos del compilador (por ejemplo,
/define:LOG) - variables de entorno del sistema operativo (
set LOG=1) - en directivas sobre vuestro propio código (directiva
#define LOG)
Eso sí, tened en cuenta que el método siempre será compilado e introducido en el ensamblado, son las invocaciones a éste las que son omitidas en caso de no existir la constante indicada.
Hay que tener en cuenta las siguientes observaciones para el uso del atributo Conditional:
- Los métodos a los que se aplica no pueden tener tipo de retorno, es decir, serán
void. Esto tiene bastante sentido, si pensamos en los efectos laterales que podría causar la desaparición de una invocación tras la cual se haga uso del valor retornado. - Sólo se pueden aplicar a métodos en clases o estructuras. Nada de interfaces (¡tampoco tendría mucho sentido!).
- Si un método virtual está marcado como
Conditional, las reescrituras de éste realizadas desde clases descendientes también lo estarán. Es bastante lógico, puesto que así se mantienen las dependencias íntegras. - Si el atributo se aplica a un método, éste no puede ser un reemplazo del comportamiento de un antecesor (o sea, que no puede ser un override). También resulta muy lógico.
En resumen, se trata de un buen método para incluir código condicional en nuestros desarrollos, dependiente del contexto de compilación, evitando tener que usar directivas #if… #endif. Pero no lo olvidéis: cuidado con los efectos laterales citados.
Publicado en: Variable not found.
La técnica consiste en crear, utilizando alguna herramienta de diseño como Adobe Acrobat, un documento PDF que contenga todos los contenidos estáticos del documento que deseamos generar. En cada zona donde queremos inyectar contenido deberemos introducir un campo de formulario (por ejemplo, “nombre”, “apellidos”, etc.) adaptando el tipo de letra, límites y las propiedades del campo que sean necesarias.
Ya desde código el procedimiento será bien sencillo: abrimos la plantilla, introducimos los valores en cada uno de los campos, y hacemos con el documento resultante lo que nos convenga según la ocasión: enviarlo por email, salvarlo a disco, ofrecerlo para la descarga, etc.
Para conseguir estos objetivos utilizaremos iTextSharp, una adaptación para .NET de la librería iText, muy conocida en el mundo Java. Por tanto, en primer lugar, es necesario descargarla desde Sourceforge, y referenciarla en el proyecto desde el cual vamos a utilizarla.
El siguiente código implementa un método realiza el procedimiento descrito:
1: public void FillPDF(string templateFile, Stream stream)
2: {3: // Abrimos la plantilla y creamos una copia, sobre
4: // la cual trabajaremos...
5: PdfReader reader = new PdfReader(templateFile);
6: PdfStamper stamp = new PdfStamper(reader, stream);
7: 8: // Introducimos el valor en los campos del formulario...
9: stamp.AcroFields.SetField("Nombre", "Juan");
10: stamp.AcroFields.SetField("Apellidos", "Rodríguez Méndez");
11: 12: // Fijamos los valores y enviamos el resultado al stream...
13: stamp.FormFlattening = true;
14: stamp.Close(); 15: }Así, para almacenar la plantilla con los datos en un nuevo PDF, bastaría con invocar al método anterior de la siguiente manera:
1: Stream file = new FileStream("FormularioRelleno.pdf", FileMode.Create);
2: FillPDF("plantilla.pdf", file);
O si queremos que desde una aplicación ASP.NET el usuario pudiera descargarlo directamente, podríamos utilizar un código como el siguiente:
1: protected void btnGenerarPDF_Click(object sender, EventArgs e)
2: { 3: Response.Clear();4: Response.ContentType = "application/pdf";
5: Response.AddHeader("content-disposition", "attachment;filename=Formulario.pdf");
6: FillPDF(Server.MapPath("Plantilla.pdf"), Response.OutputStream);
7: }Por último, sólo comentar que iTextSharp no sólo es útil para rellenar formularios, ni mucho menos. Se trata de una librería muy potente que permite la creación y edición al vuelo de documentos PDF completos, y dispone de un complejo amplísimo API que nos permite hacer casi de todo con ellos. Además, se distribuye bajo licencias LGPL y MPL, muy permisivas ambas, por lo que pueden ser utilizadas en prácticamente cualquier tipo de sistemas.
Para el que no se le apetezca teclear mucho, ahí va una solución para Visual Studio 2005 con dos proyectos, uno web y otro de consola, demostrando el funcionamiento.
Publicado en: Variable not found.
