PDF de programación - C# ASP.NET en la práctica - Desarrollo Profesional de Aplicaciones con C#

ASP.NET en la práctica

En este último capítulo dedicado a ASP.NET, trataremos algunos aspectos de interés a la hora
de construir aplicaciones reales. Después de haber visto en qué consiste una aplicaciónes web,
cómo se crean formularios web en ASP.NET y de qué forma se pueden realizar las tareas más
comunes con las que debe enfrentarse el programador de aplicaciones web, ahora
comentaremos algunos de los aspectos relativos a la organización interna de las aplicaciones
web:

- En primer lugar, comentaremos brevemente algunos de los patrones de diseño que
se suelen emplear a la hora de crear la aplicación web con el objetivo de que ésta
mantenga su flexibilidad y su mantenimiento no resulte tedioso.

- A continuación, nos centraremos en los mecanismos existentes que nos facilitan

que el aspecto externo de una aplicación web ASP.NET sea homogéneo.

- Una vez descritos los principios en los que se suelen basar las aplicaciones web
bien diseñadas, repasaremos cómo se puede hacer que el contenido de nuestra
interfaz web cambie dinámicamente utilizando un mecanismo conocido como
enlace de datos [data binding].

- Finalmente, cerraremos este capítulo centrándonos en la construcción de
formularios de manipulación de datos, como ejemplo más común del tipo de
módulos que tendremos que implementar en cualquier aplicación.

124

Desarrollo Profesional de Aplicaciones con C#

ASP.NET en la práctica

Organización de la interfaz de usuario..............................125
Componentes de la interfaz ................................... 125
El modelo MVC en ASP.NET .............................. 127
Controladores en ASP.NET................................. 129
Control de la aplicación.......................................... 135

Aspecto visual de la aplicación .........................................140
Filtros con módulos HTTP ..................................... 142
La directiva #include .............................................. 143
Plantillas................................................................. 145

Configuración dinámica de la aplicación..........................147
Listas de opciones ................................................. 149
Vectores simples: Array y ArrayList..................... 150
Pares clave-valor: Hashtable y SortedList........... 151
Ficheros XML ...................................................... 153
Conjuntos de datos ................................................ 157
El control asp:Repeater ....................................... 158
El control asp:DataList......................................... 161
El control asp:DataGrid ....................................... 163

Formularios de manipulación de datos.............................170
Edición de datos .................................................... 170
Formularios maestro-detalle en ASP.NET............. 174

© Fernando Berzal, Francisco J. Cortijo & Juan Carlos Cubero

ASP.NET en la práctica

125

Organización de la interfaz de usuario

Como Steve McConnell expone en su libro Software Project Survival Guide, la mayor parte
del trabajo que determina el éxito o el fracaso final de un proyecto de desarrollo de software
se realiza antes de que comience su implementación: "si el equipo investiga los requisitos a
fondo, desarrolla el diseño con detalle, crea una buena arquitectura, prepara un plan de
entrega por etapas y controla los cambios eficazmente,
la construcción [del software]
destacará por su firme progreso y la falta de problemas graves". Obviamente, la lista de
condiciones que se han de cumplir para que un proyecto de desarrollo de software finalice con
éxito es extensa, como no podía ser menos dada la complejidad de las tareas que han de
realizarse.

En los primeros apartados de este capítulo nos centraremos en una de las bases que sirven de
apoyo al éxito final del proyecto: la creación de una buena arquitectura. En concreto, veremos
cómo se pueden organizar los distintos elementos que pueden formar parte de la interfaz web
de una aplicación realizada con ASP.NET.

Componentes de la interfaz

La primera tentación de un programador de aplicaciones web consiste en escribir todo el
código de su aplicación en la propia página ASP.NET. Sin embargo, en cuanto la aplicación
comienza a crecer, empiezan a aparecer cierta redundancia. La existencia de fragmentos de
código duplicados complicarán el mantenimiento de la aplicación y la realización de nuevas
mejoras.

Cuando situaciones como esta se presentan, lo usual es encapsular la lógica de la aplicación
en componentes independientes. La redundancia se elimina a cambio de un incremento en la
complejidad de la aplicación. Cuanto más compleja sea la aplicación, más difícil será que
otros programadores sean capaces de entender correctamente su funcionamiento. Por tanto, la
complejidad introducida también dificulta el mantenimiento de la aplicación, aunque sea en
un sentido totalmente diferente al causado por la existencia de código duplicado.

Afortunadamente, existen soluciones bien conocidas que consiguen dotar a las aplicaciones de
cierta flexibilidad sin incrementar excesivamente su complejidad. En el caso del desarrollo de
interfaces de usuario,
la solución más conocida es el patrón de diseño MVC
[Model-View-Controller], en el que se distinguen tres componentes bien diferenciados:

- El modelo encapsula el comportamiento y los datos correspondientes al dominio
de la aplicación. Habitualmente se construye un modelo de clases del problema
con el que se esté trabajando, independientemente de cómo se vayan a presentar
los datos de cara al usuario.

http://csharp.ikor.org/

126

Desarrollo Profesional de Aplicaciones con C#

- Las vistas consultan el estado del modelo para mostrárselo al usuario. Por
ejemplo, un mismo conjunto de datos puede verse en forma de tabla o
gráficamente, en una pantalla o en un informe impreso. Cada una de las formas de
mostrar los constituye una vista independiente y, en vez de tener en cada vista el
código necesario para acceder directamente a los datos, cada una de las vistas
delega en el modelo, que es el responsable de obtener los datos y realizar los
cálculos necesarios.

- Los controladores, por último, son los encargados de permitir que el usuario
realice acciones. Dichas acciones se traducirán en las respuestas que resulten
apropiadas, las cuales pueden involucrar simplemente a las vistas o incluir la
realización de operaciones sobre el modelo.

El modelo MVC: Las vistas y los controladores dependen del modelo, pero
el modelo no depende ni de la vista ni del controlador. Esto permite que el
modelo se pueda construir y probar independientemente de la presentación

visual de la aplicación. Además, se pueden mostrar varias vistas de los

mismos datos simultáneamente.

El modelo MVC ayuda a modularizar correctamente una aplicación en la cual el usuario
manipula datos a través de una interfaz. Si el usuario puede trabajar con los mismos datos de
distintas formas, lo habitual es encapsular el código compartido en un módulo aparte con el
fin de evitar la existencia de código duplicado. Se puede decir que el modelo contiene el
comportamiento común a las distintas formas que tiene el usuario de manipular los datos. De
hecho, la existencia de un modelo independiente facilita enormemente la construcción de
sistemas que han de ofrecer varios interfaces. Este sería el caso de una empresa que desea
disponer de una aplicación Windows para uso interno de sus empleados, una interfaz web
para que sus clientes puedan realizar pedidos y un conjunto de servicios web para facilitar el
intercambio de datos con sus proveedores.

© Fernando Berzal, Francisco J. Cortijo & Juan Carlos Cubero

ASP.NET en la práctica

127

De hecho, aunque el usuario trabaje con los datos de una única forma, el código
correspondiente a la interfaz suele cambiar más frecuentemente que el código correspondiente
a la lógica de la aplicación. Por ejemplo, es bastante habitual cambiar el aspecto visual de una
aplicación manteniendo su funcionalidad intacta. Eso sucede cada vez que ha de adaptarse la
interfaz a un nuevo dispositivo, como puede ser un PDA cuya resolución es mucho más
limitada que la de un monitor convencional.

En el caso de las aplicaciones web, los conocimientos necesarios para crear la interfaz (en
HTML dinámico por lo general) suelen ser diferentes de los necesarios para implementar la
lógica de la aplicación (para la que se utilizan lenguajes de programación de alto nivel). Por
consiguiente, la separación de la interfaz y de la lógica de la aplicación facilita la división del
trabajo en un equipo de desarrollo.

Por otro lado, cualquier modificación requerirá comprobar que los cambios realizados no han
introducido errores en el funcionamiento de la aplicación. En este sentido, mantener los
distintas partes de una aplicación lo menos acopladas posible siempre es una buena idea.
Además, comprobar el funcionamiento de la interfaz de usuario es mucho más complejo y
costoso que realizar pruebas de unidad sobre módulos independientes (algo que describiremos
en la última parte de este libro cuando veamos el uso de NUnit para realizar pruebas de
unidad).

Una de las decisiones de diseño fundamentales en la
construcción de software es aislar la interfaz de la lógica de la
aplicación. Al fin y al cabo, el éxito del modelo MVC radica
en esa decisión: separar la lógica de la aplicación de la lógica
correspondiente a su presentación.

En los dos próximos apartados veremos cómo se utiliza el modelo MVC en ASP.NET y cómo
se pueden crear controladores que realicen tareas comunes de forma uniforme a lo largo y
ancho de nuestras aplicaciones.

El modelo MVC en ASP.NET

Las aplicaciones web utilizan una variante del modelo MVC conocida como MVC pasivo
porque las vistas sólo se actualizan cuando se realiza alguna acción a través del controlador.
Esto es, aunque el estado del modelo se vea modificado,
la vista no se actualizará
automáticamente. El navegador del usuario muestra la vis