Desarollo de Aplicaciones Windows Con WPF 4.0 (Ejemplo)

De sarrol Desarr olllo de aplica apl icaci cion ones es Window Win dowss con WPF 4 .0 Aroa Ar oa Solana Solana

1

Sinopsis Durante muchos años, el desarrollo de aplicaciones de escritorio para el sistema operativo Windows ha hecho uso de los tradicionales tradici onales Formularios (Windows Forms), adaptándose a las nuevas necesidades de negocio de las empresas y a las funcionalidades del propio sistema. Es ahora, con la llegada ll egada de .NET Framework 4.0 y Visual Studio 2010, cuando Microsoft ha decidido darle una nueva vuelta de tuerca a este tipo de desarrollos con Windows Presentation Foundation 4.0. Las mejoras en el enlace de propiedades y la mayor capacidad multimedia y gráfica, hacen que WPF 4.0 sea la plataforma de desarrollo Windows del futuro. En el presente texto se verán en detalle temas como enlace de datos, animaciones, notificaciones al usuario, enlace enla ce de propiedades y el despliegue de los paquetes XAP. Dado que en WPF 4.0 se hacen uso tanto del lenguaje de programación C# 4.0 como del lenguaje de marcado XAML, los ejemplos combinarán ambos para que el lector comprenda su finalidad.

Aroa Solana Ruiz es Microsoft Certified IT Professional en Database Developer, también Microsoft Certified Technology Specialist en SQL Server 2005, .NET Framework 3.5, Windows Forms Applications, SQL Server 2005, al igual que Database Development en SQL Server 2008. Actualmente ostenta la certificación MCT (Microsoft Certified Trainer) que la permite impartir un gran número de cursos oficiales de Microsoft y trabajar como formadora en

Alhambra-Eidos. Ha impartido formación sobre la tecnología .NET, desarrollo de aplicaciones Windows, Web, ADO, Distribuidas, WPF, WCF, WWF, Silverlight y UML, por otra parte imparte formación en administración de bases de datos SQL SQL Server y desarrollo de bases de datos SQL Server, tanto en 2005 como en 2008. 2008 . Además posee experiencia en  J2SE y J2EE. Dentro de la gestión de procesos posee la certificación ITIL V2 Foundations.

Luarna Desarrollo de aplicaciones Windows con WPF 4.0 © Aroa Solana Solana - Alhambra Eidos © De esta edición: 2010, Luarna Ediciones, S.L.

www.luarna.com Madrid, noviembre de 2010 ISBN: 978-84-92684-95-3 978-84-92684-95-3 Versión 1.0 (03-11-2010)

Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra solo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de Derechos Reprográficos, Reprográficos, www.cedro.org www.cedro.org)) si necesita fotocopiar, escanear o hacer copias digitales de algún fragmento de esta obra.

Desarrollo de aplicaciones Windows con WPF 4.0

Aroa Solana Ruiz

Este libro, se lo dedico a mis Amigos Tamara y Fran que se acaban de casar y que espero que sean muy felices, a Jara y Lucia y a la pequeña Victoria, también quiero dedicárselo a Vero y Agus que a demás de ser todos ellos mis vecinos son mis mejores amigos que me han hecho pasar los mejores ratos y me han hecho la vida más amena.

Indice

Introducción....................................................................................................................................15 La llegada de una nueva versión ....................................................................................................15 Mejoras en el .NET Framework 4.0...............................................................................................15 Novedades en Visual Studio 2010 ................................................................................................. 15 Formularios Windows ...................................................................................................................16 Windows Presentation Foundation ................................................................................................16 Lenguajes de desarrollo.................................................................................................................17 Iniciando la andadura .................................................................................................................... 17 Diseño de aplicaciones Windows .................................................................................................... 18 Visual Studio Tools para el desarrollo de aplicaciones basadas en Windows .................................. 19 Diseñadores visuales para formularios Windows ....................................................................... 19 Diseñadores visuales de Windows Presentation Foundation ....................................................... 20 Vista de diseño ......................................................................................................................21 Vista XAML ......................................................................................................................... 22 Entender Windows Forms ............................................................................................................. 23 Arquitectura de Windows Forms ...............................................................................................24 Entender Windows Presentation Foundation..................................................................................24 Arquitectura de WPF.................................................................................................................25 Aplicaciones de navegador XAML ............................................................................................25 Windows Forms VS Windows Presentation Foundation ................................................................ 26 Elegir la tecnología cliente apropiada ........................................................................................27 Patrones Arquitectónicos...............................................................................................................28 Patrones de Diseño .................................................................................................................... 28 Patrones en el Framework de .NET........................................................................................28 Según su propósito ................................................................................................................ 29 Según su ámbito .................................................................................................................... 29 Abstract Factory ....................................................................................................................30 Builder ..................................................................................................................................33 Factory .................................................................................................................................. 34 Singleton ...............................................................................................................................37 Composite .............................................................................................................................38 Decorator ..............................................................................................................................39 Proxy ....................................................................................................................................40 Interpreter .............................................................................................................................42 Iterator ..................................................................................................................................42 Mediator................................................................................................................................44 Memento ...............................................................................................................................45 Observer................................................................................................................................46 Visual Studio 2010 y WPF 4.0 ........................................................................................................49 Novedades en Visual Studio 2010 ................................................................................................. 49 Novedades en Visual C# 4.0..........................................................................................................52 Novedades en WPF 4 ....................................................................................................................53 Introducción al Diseñador de WPF ............................................................................................53 XAML ..................................................................................................................................53 Vista Dividida ...................................................................................................................54 Mejoras .............................................................................................................................55 Nuevas características ...............................................................................................................55 Visual State Manager ............................................................................................................ 56 7

Gráficos y Animaciones ........................................................................................................ 56 Texto ........................................................................................................................................57 Nuevas características adicionales en WPF 4.................................................................................57 Pantalla táctil y manipulación ....................................................................................................57 Enlaces .....................................................................................................................................57 Aplicaciones de navegador XAML ........................................................................................58 WPF y Windows ...................................................................................................................59 Diseñador de WPF ................................................................................................................59

Diseño e implementación de IU ......................................................................................................60 Definir el diseño de página ............................................................................................................60 Modelo de diseño de página en WPF .........................................................................................60 Cuadros de límites de elementos ............................................................................................61 Consideraciones de rendimiento de diseño ............................................................................. 62 Clases de diseño en WPF ..............................................................................................................63 Miembros comunes de los elementos Panel ...............................................................................63 Elementos Panel derivados........................................................................................................66 Soporte para Localización y Globalización ................................................................................66 Panel Canvas .........................................................................................................................67 Panel DockPanel ...................................................................................................................69 Panel Grid .............................................................................................................................70 Panel StackPanel ...................................................................................................................75 Panel WrapPanel ...................................................................................................................76 Controles de Contenido.................................................................................................................77 Modelo de Contenido “Decorator .............................................................................................. 95 Controles con Encabezado ............................................................................................................ 95 Controles que contienen una colección ..........................................................................................99 Manejar la selección de elementos ........................................................................................... 113 Propiedades de selección de ListBox .......................................................................................113 Compartir recursos lógicos en una ventana .................................................................................. 114 Definir recursos....................................................................................................................... 114 Referenciar recursos en XAML ............................................................................................... 116 Recursos estáticos ...............................................................................................................117 Recursos dinámicos ............................................................................................................. 118 Personalizar interfaces de usuario ...............................................................................................121 Compartir recursos lógicos en una aplicación .............................................................................. 121 Acceso a los recursos mediante código .................................................................................... 123 Crear recursos mediante código ............................................................................................... 123 Diccionario de recursos compartidos ....................................................................................... 124 Uso de diccionarios combinados con código ........................................................................124 Crear interfaces consistentes ....................................................................................................... 125 Estilos ..................................................................................................................................... 125 Definir estilos en XAML .....................................................................................................126 Establecer estilos programáticamente .................................................................................. 129 Plantillas .................................................................................................................................129 Temas ..................................................................................................................................... 129 Propiedad IsItemsHost ............................................................................................................133 Elemento ItemsPanelTemplate ................................................................................................133 Elemento ItemsPresenter .........................................................................................................134 Uso de enlaces en plantillas .....................................................................................................134 Disparadores ...........................................................................................................................135 Disparadores de Propiedad .................................................................................................. 135 Disparadores de eventos y animaciones ...............................................................................136 MultiTrigger, DataTrigger y MultiDataTrigger .................................................................... 137

8

Manejo de Eventos y Comandos .................................................................................................140 Eventos ...................................................................................................................................141 Eventos Enrutados ...............................................................................................................141 Implementar eventos enrutados........................................................................................143 Manejadores de eventos en XAML ..................................................................................143 ¿Por qué utilizar eventos enrutados? ................................................................................144 EventSetters y EventTriggers...............................................................................................145 Eventos de Entrada .............................................................................................................. 146 Comandos ...............................................................................................................................147 El comando .........................................................................................................................149 El Origen............................................................................................................................. 149 El enlace ............................................................................................................................. 150 El Destino ........................................................................................................................... 151

Pruebas y Depuración...................................................................................................................152 Estrategias de Prueba en WPF .....................................................................................................152 Pruebas unitarias .....................................................................................................................153 Pruebas de integración.............................................................................................................154 Pruebas de Regresión .............................................................................................................. 155 Generar una biblioteca de comprobaciones .......................................................................... 155 Estrategias para probar aplicaciones cliente de Windows ............................................................. 156 Pruebas unitarias .....................................................................................................................156 Patrón Inversión de Control (IoC)........................................................................................156 Inyección de Dependencia ................................................................................................... 158 Automatización de IU ............................................................................................................. 160 Pruebas unitarias en Visual Studio............................................................................................... 161 Pruebas con Automatización IU ..................................................................................................162 Depuración XAML .....................................................................................................................164 Mostrar información de seguimiento de WPF ..........................................................................164 Usar el visualizador de árboles de WPF ...................................................................................167 Para abrir el visualizador de árboles de WPF: ......................................................................167 Para buscar en el árbol visual ........................................................................................... 169 Para buscar en la lista de propiedades .............................................................................. 169 Para cerrar el visualizador ................................................................................................ 170 Depurar a través de trazas........................................................................................................ 170 Proporcionar un feedback para excepciones no manejadas...........................................................171 Excepciones no manejadas ...................................................................................................... 171 Manejar excepciones no manejadas ......................................................................................... 171 Procesar excepciones no manejadas ......................................................................................... 171 Características de Seguridad........................................................................................................172 Simplificación de las directivas de seguridad ...........................................................................173 Seguridad en el acceso al código .............................................................................................173 Funciones principales de la seguridad de acceso del código ................................................. 174 Determinar si el código tiene autorización ...........................................................................174 Seguridad de confianza parcial ................................................................................................175 Enlace a Datos y Validaciones ......................................................................................................177 Propiedades de dependencia ........................................................................................................177 Modelo de enlace a datos en WPF ...............................................................................................178 Dirección de flujo en el enlace.................................................................................................179 Orígenes de datos ................................................................................................................ 180 Tipos de origen de enlace ................................................................................................ 180 Implementar una clase para el origen del enlace ............................................................... 181 Permisos en el enlace de datos .........................................................................................182 Crear un enlace de datos ..........................................................................................................182

9

Enlazar a una propiedad de clase ......................................................................................... 183 Enlazar múltiples controles a una clase ................................................................................ 184 Enlazar a un objeto completo ............................................................................................... 186 Enlazar a datos XML........................................................................................................... 186 Enlazar con controles de IU .................................................................................................187 Notificación de cambio ............................................................................................................... 188 Notificaciones de cambio en las propiedades ........................................................................... 188 Propagar la notificación de cambio .......................................................................................... 188 Implementar la notificación de cambio mediante propiedades de dependencia ..................... 189 Implementar la notificación de cambio mediante la interfaz INotifyPropertyChanged .......... 189 Conversión de Datos ................................................................................................................... 193 Conversiones predeterminadas ................................................................................................193 Implementar un convertidor personalizado .............................................................................. 193 Validar Datos ..............................................................................................................................194 Asociar reglas de validación a un enlace..................................................................................194 Proporcionar comentarios visuales .......................................................................................... 196 Presentar Datos en tiempo de Diseño...........................................................................................201 Atributos en tiempo de diseño .................................................................................................202

Enlace a datos con colecciones...................................................................................................... 204 Enlace a colecciones ................................................................................................................... 204 Observable Collection ............................................................................................................. 205 Introducción a LINQ ............................................................................................................... 206 Operadores de consulta........................................................................................................206 Integración con SQL........................................................................................................207 Integración con XML ...................................................................................................... 208 Enlace a LINQ Data Sources ...........................................................................................208 Enlace a Objetos de Datos ........................................................................................................... 213 Uso de collection view ................................................................................................................ 214 La clase CollectionView..........................................................................................................214 Crear una collection view ....................................................................................................214 Ordenar datos mediante una Collection View....................................................................... 215 Crear Interfaces de usuario Master-Detail ....................................................................................215 Plantillas de datos ....................................................................................................................... 218 Usar disparadores en la plantillas de datos ............................................................................... 225 Selectores en la plantilla de datos ............................................................................................226 Mejora en la respuesta de la IU ....................................................................................................230 Threading y Procesamiento asíncrono .........................................................................................230 Procesamiento Asíncrono ........................................................................................................ 231 Implementar Procesamiento asíncrono mediante el uso de la clase Dispatcher ......................... 231 Programar prioridades de elementos de trabajo .................................................................... 231 Programar ejecución periódica en los elementos de trabajo .................................................. 233 Implementar el procesamiento asíncrono a través de la clase ThreadPool ................................. 233 Clase ThreadPool ................................................................................................................234 Implementar el procesamiento asíncrono con la clase BackgroundWorker ............................... 235 Implementar El procesamiento Asíncrono mediante el uso de la TPL ...................................... 240 Ajustar las operaciones APM en una tarea ............................................................................... 240 Integración de la Localización y Ayuda .......................................................................................242 Localizacion y Globalización .................................................................................................. 242 Características de la localización WPF ....................................................................................243 Diseño automático ............................................................................................................... 243 Localización de Atributos y comentarios .............................................................................245 Soporte para contenido Bidireccional ............................................................................... 245 Características de la localización WPF ....................................................................................245 10

Implementar aplicaciones WPF Localizadas a través de la herramienta LocBaml ..................... 246 Implementar Aplicaciones WPF localizadas a través de recursos fuertemente tipados .............. 247 Uso de Recursos de tipos Inflexibles...................................................................................248 Implementar Características de Ayuda al usuario.........................................................................248 Implementar Ayuda contextual................................................................................................248 Mostrar Archivos de Ayuda .................................................................................................249 Implementar Características de ayuda mediante el uso de Tooltips........................................... 249 Crear un ToolTip ................................................................................................................. 250 Proporcionar Características de accesibilidad de usuarios ............................................................ 251 Comprobar la accesebilidad.....................................................................................................252 Implementar características de accesibilidad en aplicaciones WPF........................................... 252 Navegación Peer.................................................................................................................. 253 Implementar un control personalizado ................................................................................. 253 Sobrescribir el método OnCreateAutomationPeer ............................................................ 253 Sobrescribir el método GetPattern .................................................................................... 253 Invalidar métodos básicos ("Core") .................................................................................. 254

Graficos 2D, Multimedia e impresión ..........................................................................................256 Crear Gráficos en 2D ..................................................................................................................257 Geometries ..............................................................................................................................257 Tipos de geometrías.............................................................................................................257 Brushes ...................................................................................................................................262 Utilizar un Brush ..................................................................................................................... 262 Dibujar Formas .......................................................................................................................265 Diferencias entre Path y Geometrie .........................................................................................265 Transformaciones....................................................................................................................267 Clases de transformación.....................................................................................................267 Propiedades comunes ..........................................................................................................270 Uso del sistema de coordenadas ...........................................................................................271 Animar transformaciones ..................................................................................................... 272 Mostrar Imágenes .......................................................................................................................273 Componentes WPF para imágenes........................................................................................... 273 Codificar y Decodificar Imágenes ...........................................................................................275 Codificación de formatos de imagen .................................................................................... 276 Rotar, Convertir y Cortar imágenes ......................................................................................... 276 Multimedia .................................................................................................................................278 Modos de reproducción multimedia ......................................................................................... 278 Modo independiente ............................................................................................................279 MediaElement .....................................................................................................................282 Controlar MediaElement.................................................................................................. 282 Mostrar MediaElement ....................................................................................................283 Clase MediaPlayer ............................................................................................................... 283 Controlar MediaPlayer..................................................................................................... 284 Mostrar MediaPlayer .......................................................................................................284 Crear e imprimir Documentos ..................................................................................................... 284 Documentos Fijos y Dinámicos ............................................................................................... 284 Documentos Fijos ................................................................................................................ 284 Documentos Dinámicos....................................................................................................... 285 Definir documentos Fijos y Dinámicos ....................................................................................285 Vista de documentos Fijos y Dinámicos ..................................................................................286 Especificación XML Paper......................................................................................................289 Controlar trabajos de impresión ...............................................................................................289 Manejar la cola de Impresión...................................................................................................291 Uso de la clase PrintServer .................................................................................................. 291 Controles Personalizados.............................................................................................................. 292 11

Necesidad de crear nuevos controles ...........................................................................................292 Opciones para crear nuevos controles .......................................................................................... 293 Heredar de UserControl...........................................................................................................293 Heredar de Control .................................................................................................................. 294 Heredar de FrameworkElement ............................................................................................... 294 Implementar Controles de Usuario ..............................................................................................295 Pasos para crear un control de usuarios....................................................................................295 El control XamlFileBrowser ................................................................................................ 295 Implementar controles Personalizados.........................................................................................297 Pasos para crear un control personalizado................................................................................297 Heredar de la clase FrameworkElement .......................................................................................306 Implementar Comandos ..............................................................................................................306 Conceptos básicos ...................................................................................................................307 Commands ..........................................................................................................................307 Orígenes de comando .......................................................................................................... 308 CommandBinding ...............................................................................................................309 Destino de comando ............................................................................................................310 CommandManager .............................................................................................................. 311 Comandos personalizados ....................................................................................................... 311 Mejora en los controles a través de Temas...................................................................................311 Definir el atributo ThemeInfo .................................................................................................. 315 Gestionar la apariencia de los controles mediante estados visuales............................................... 315 Clase VisualStateManager .......................................................................................................315 Cambiar la apariencia de un control según su estado ................................................................ 316 Especificar el comportamiento en las transiciones ................................................................ 319 Especificar la duración de la transición ............................................................................ 320 Especificar cambios en la apariencia en la transición ........................................................ 320 Integrar WPF y Windows Forms ................................................................................................. 323 Alojar controles Windows Forms en aplicaciones WPF ........................................................... 323 Mapear propiedades WPF a Windows Forms ....................................................................... 324 Asignar Propiedades mediante WindowsFormHost .......................................................... 324 Alojar controles WPF en una aplicación Windows Forms ........................................................ 326

Propiedades y Comportamientos ................................................................................................. 327 Propiedades Asociadas................................................................................................................ 327 Usar propiedades asociadas ..................................................................................................... 328 Propiedades asociadas en el código......................................................................................329 Implementar propiedades asociadas.........................................................................................329 Metadatos de propiedad asociados ........................................................................................... 330 Descriptor de acceso Get ..................................................................................................... 330 Descriptor de acceso Set ...................................................................................................... 330 Implementar interfaces de usuario Arrastrar-y-Soltar ................................................................... 331 Eventos Arrastrar y Soltar .......................................................................................................331 Implementar operaciones Arrastrar-y-Soltar ............................................................................ 332 Animaciones en WPF....................................................................................................................335 Animaciones ...............................................................................................................................335 Tipos de animaciones .............................................................................................................. 336 Storyboards .............................................................................................................................338 Definir Animaciones ...............................................................................................................338 Funciones de aceleración ..................................................................................................... 338 Controlar Animaciones............................................................................................................ 342 Disparadores ...............................................................................................................................343 Definir Event Triggers.............................................................................................................344 Definir property triggers..........................................................................................................345

12

Visualización de Datos................................................................................................................346

Configurar y Desplegar aplicaciones............................................................................................349 Opciones de Implementación ...................................................................................................... 349 Implementación XCopy ..........................................................................................................349 Windows Installer ...................................................................................................................350 Implementación ClickOnce .....................................................................................................350 Implementar aplicaciones de WPF ........................................................................................... 350 Implementar aplicaciones independientes ............................................................................ 350 Implementar aplicaciones sólo en XAML ........................................................................... 351 Implementar aplicaciones de explorador XAML .................................................................. 351 XBAPs en la intranet local...................................................................................................351 Desplegar un aplicacion WPF Stand-alone ..................................................................................353 Desplegar una aplicación WPF Stand-alone mediante ClickOnce ............................................ 353 Desplegar una aplicación WPF Stand-alone mediante Windows Installer................................. 353 Desplegar una aplicación XBAP .................................................................................................354 Archivos XBAP que deben ser desplegados............................................................................. 354 Configurar Opciones de Seguridad .............................................................................................. 355 Generación de Manifiesto y herramientas de Edición ............................................................... 355 Mage.exe ................................................................................................................................355 Parámetros ..........................................................................................................................355 MegeUI.exe ............................................................................................................................358 Miembros de Paneles .................................................................................................................... 360 Canvas ........................................................................................................................................ 360 Métodos ..................................................................................................................................360 Campos ...................................................................................................................................361 Propiedades .............................................................................................................................362 Propiedades asociadas ............................................................................................................. 368 Eventos ...................................................................................................................................369 DockPanel ..................................................................................................................................374 Constructores ..........................................................................................................................374 Métodos ..................................................................................................................................374 Campos ...................................................................................................................................375 Propiedades .............................................................................................................................375 Propiedades asociadas ............................................................................................................. 379 Eventos ...................................................................................................................................379 Grid ............................................................................................................................................ 384 Constructores ..........................................................................................................................384 Métodos ..................................................................................................................................385 Campos ...................................................................................................................................386 Propiedades .............................................................................................................................386 Propiedades asociadas ............................................................................................................. 392 Eventos ...................................................................................................................................393 StackPanel ..................................................................................................................................399 Constructores ..........................................................................................................................399 Métodos ..................................................................................................................................399 Campos ...................................................................................................................................401 Propiedades .............................................................................................................................401 Eventos ...................................................................................................................................406 WrapPanel ..................................................................................................................................412 Constructores ..........................................................................................................................412 Métodos ..................................................................................................................................413 Campos ...................................................................................................................................413 Propiedades .............................................................................................................................413

13

Eventos ...................................................................................................................................418

Caso de Uso ................................................................................................................................... 425

14

Introducción La llegada de una nueva versión Largo tiempo ha transcurrido (teniendo en cuenta que en informática, un periodo de 4 ó 5 años supone una eternidad) desde la presentación de la primera versión de la arquitectura .NET Framework, una novedosa plataforma para el desarrollo de aplicaciones en entorno Windows, Web, servicios, etc., y Visual Studio .NET, como evolución del clásico IDE (Entorno de desarrollo integrado) de Microsoft, adaptado a esta nueva plataforma de desarrollo. Desde el momento en que las anteriormente mencionadas tecnologías fueron presentadas, muchos cambios y avances se han sucedido en el mundo del desarrollo de aplicaciones, que como proceso natural, han tenido su reflejo y dado como fruto sendas nuevas versiones de estos productos. Así  pues, nos encontramos actualmente ante .NET Framework versión 4.0, y Vi sual Studio 2010.

Mejoras en el .NET Framework 4.0 Muchas han sido las nuevas capacidades y características mejoradas en la plataforma, entre las que podemos mencionar los nuevos parámetros opcionales, los parámetros nombrados, los tipos dinámicos la covarianza y la contravarianza entre otros que dotan a los lenguajes compatibles con .NET de una mayor potencia y flexibilidad. Las características de internacionalización, para potenciar la creación de aplicaciones fácilmente adaptables al entorno de idioma y cultural del sistema en el que se ejecuten. Monitorización del estado de conectividad de red. Mejoras en un largo etcétera de características que incrementarán nuestra productividad en la siempre laboriosa tarea del desarrollo de soluciones de software.

Novedades en Visual Studio 2010 La herramienta con la que día a día desarrollamos nuestro trabajo también se ha visto renovada en múltiples aspectos, comenzando por una reorganización de los tipos de aplicación y agregación de nuevas plantillas, que harán al desarrollador más fácil su tarea de crear nuevos proyectos. Se han incorporado nuevos asistentes y mejorado los ya existentes, existiendo una amplia profusión de ayudas al contexto para las más diversas tareas. También es posible exportar la configuración general del IDE, de forma que podemos llevarnos dicha configuración a otra instalación de Visual Studio 2010 y aplicarla, disponiendo rápidamente de nuestros ajustes favoritos de colores, editor de código, org anización de ventanas, etc. Intellisense avisa y sugiere ahora en muchas más situaciones que en la anterior versión, visualiza una mayor cantidad de información tanto en tiempo de desarrollo como en ejecución mediante los DataTips y disponemos de la capacidad de realizar Refactoring, para reestructurar nuestro código de una manera muy sencilla y rápida. Los Code Snippets o recortes de código, nos permiten insertar bloques de código preconstruido, que en muchas ocasiones repetimos, ahorrando una gran cantidad de tiempo y evitando también errores de escritura. Nos encontramos entonces, ante un entorno integrado en este caso de Visual C#, que es lenguaje que utilizaremos a lo largo de este libro. Una de las novedades de este entorno es en la jerarquía de llamadas. La jerarquía de llamadas permite navegar por el código mostrando los siguientes elementos: 

15

Todas las llamadas destinadas y procedentes de un método, una propiedad o un constructor seleccionados.

 

Todas las implementaciones de un miembro de interfaz Todos los reemplazos de un miembro virtual o abstracto

Esto permite entender mejor cómo fluye el código y evaluar los efectos de los cambios que se realizan en el código. Además, se puede usar la característica de Navegar a para buscar un símbolo o un archivo en código fuente. Puede buscar palabras clave incluidas en un símbolo, concatenadas mediante notación Camel o caracteres de subrayado a fin de dividir dichos símbolos en palabras clave. Otra característica de este editor, es que al hacer clic en un símbolo en el código fuente, todas las instancias de ese símbolo se resaltan en el documento. Para desplazarse al siguiente o anterior símbolo resaltado, puede usar CRTL+MAYÚS+FLECHA ABAJO o CRTL+MAYÚS+FLECHA ARRIBA. Otra característica destacable es “Generar a partir del uso”, esta característica permite usar clases y miembros antes de definirlos. Desde la ubicación actual en el código, se puede generar un código auxiliar para una clase, un constructor, un método, una propiedad, un campo o una enumeración que se desea usar pero que aún no se ha definido. De este modo, se minimizan las interrupciones en el flujo de trabajo. IntelliSense como se comentaba anteriormente proporciona dos alternativas para completar las instrucciones de Intellisense: el modo de finalización y el modo de sugerencia. El modo de sugerencia se utiliza cuando las clases y los miembros se usan antes de definirlos. La característica Semantic Errors Live se ha mejorado en Visual C# 2010.El uso de subrayado ondulado para señalar errores y advertencias cuando se escribe se ha ampliado para incluir estructuras que están fuera de los cuerpos del método, como tipos de valor devuelto, tipos de parámetro y valores predeterminado en declaraciones de método.

Formularios Windows Esta es una obra que trata sobre desarrollo de aplicaciones para entorno Windows (Windows Forms), por lo tanto, no podíamos dejar la introducción a la misma sin hacer una breve mención a las novedades que la plataforma .NET incorpora a este tipo de interfaz de usuario. En el apartado de controles nos encontramos con BackgroundWorker, para procesos intensivos a realizar en segundo plano; DataGridView, como cuadrícula mejorada de presentación de datos; ToolStrip, para la creación del menú del formulario, tanto de barra como contextual; SoundPlayer, para la generación de sonidos; WebBrowser, para dotar de capacidades de navegación Web a un formulario de Windows, etc. Respecto a las operaciones de enlace de datos ( DataBinding ), disponemos de la nueva familia de componentes BindingXXX, que facilitan el proceso de enlace y navegación. Una de las mayores dificultades de las aplicaciones Windows ha sido desde siempre su complejidad de instalación. La nueva tecnología ClickOnce se ha desarrollado para solventar esta problemática, permitiendo que el proceso de instalación sea tan sencillo como en las aplicaciones Web.

Windows Presentation Foundation Windows Presentation Foundation (WPF) es un sistema de presentación de la próxima generación, para crear aplicaciones cliente de Windows que proporcionen una experiencia impactante para el usuario desde el punto de vista visual. Con WPF, puede crear una amplia gama de aplicaciones independientes y hospedadas en el explorador. El núcleo de WPF es un motor de representación basado en vectores independiente de la resolución que se crea para sacar partido del hardware de gráficos moderno. WPF extiende el núcleo con un conjunto completo de características de desarrollo de aplicaciones que incluye el lenguaje XAML, controles, enlace de datos, diseño, gráficos 2D y 3D, animación, estilos, plantillas, documentos, multimedia, texto y tipografía. WPF se incluye en Microsoft .NET Framework, de modo que es posible compilar aplicaciones que incorporen otros elementos de la biblioteca de clases de .NET Framework.

16

Lenguajes de desarrollo El motor de ejecución, CLR (Common Language Runtime), de la plataforma .NET Framework, está diseñado para soportar diferentes lenguajes de programación, siempre que estos hayan sido diseñados bajo unas pautas comunes de funcionamiento establecidas en la especificación CLS (Common Language Specification) de la tecnología .NET. Así tenemos implementaciones de lenguaje y compiladores para Visual Basic, Visual C#, Visual C++, Visual J#, y un largo etcétera de lenguajes desarrollados por Microsoft y terceros fabricantes. De esta forma podemos desarrollar nuestras aplicaciones utilizando la sintaxis en la que nos encontremos más cómodos, con la seguridad de que el resultado final será el mismo, independientemente del lenguaje utilizado, dado que bajo la arquitectura de .NET, los compiladores de los diferentes lengua jes generan un código intermedio común (MSIL, Microsoft Intermediate Language), que será el que finalmente se transforme en el código binario ejecutable. Abarcar todos los lenguajes en una obra como la presente resulta complejo, dado que nuestro objetivo no es abordar las características de los diferentes lenguajes de la plataforma, sino el desarrollo de aplicaciones para un determinado tipo de interfaz de usuario. Es por ello, que para los diferentes ejemplos emplearemos el lenguaje que actualmente disfruta de una mayor difusión por parte de la comunidad de programadores: Visual C#.

Iniciando la andadura Tras el periodo inicial de despegue y asentamiento que suponen las primeras versiones, .NET Framework 4.0 se afianza como una sólida tecnología para el desarrollo de soluciones orientadas a las más diversas necesidades, que en el caso concreto de la presente obra es la creación de aplicaciones Windows. El elenco se completa con Visual Studio 2010, como banco de trabajo que nos ofrece todas las herramientas necesarias para la construcción de este tipo de aplicaciones, junto a Visual C# como lenguaje y compilador para la producción del código de nuestros programas. Confiamos que el presente texto resulte de interés al lector, tanto si se acerca por primera vez a este tipo de aplicaciones, como si teniendo ya experiencia con el entorno, desea reciclarse en las novedades que aporta esta última versión.

17

Diseño de aplicaciones Windows Es importante que se entienda cómo los requisitos distintos requisitos de negocio influencian nues-

tras decisiones de diseño cuando estamos planeando una aplicación de Windows, y que patrones están disponibles para ayudar a resolver las necesidades actuales del negocio. Numerosos factores influyen en la consideración de la tecnología apropiada para usar en cualquier desarrollo o plataforma; en el desarrollo de aplicaciones Windows mediante el Framework de .NET no es diferente. Hay dos tecnologías para elegir, y que pueden ser ventajosas en varios sentidos, dependiendo de los requisitos del diseño y del negocio, claro. Pero, ¿cuáles son esas dos tecnologías? Porque hasta ahora parecía que eran los Windows Forms, bueno pues desde el Framework 3.0 surge Windows Presentation Foundation. Antes de nada, destacar que las aplicaciones Windows que están creadas mediante el Framework de .NET ofrecen múltiples beneficios. Podemos acceder a servicios del sistema operativo y tomar ventaja de otros beneficios que proporcionan los entornos de ejecución. Podemos devolver datos para aplicaciones Windows a través de varias tecnologías de acceso a datos. Las aplicaciones Windows pueden realizar llamadas a métodos que expuestos por servicios Web XML, los cuales permiten aprovechar la información y los recursos de una variedad de orígenes. Como se ha comentado, hay dos tecnologías Windows que permiten construir aplicaciones Windows utilizando el Framework de .NET, estas son: Windows Forms y Windows Presentation Foundation.

18

Visual Studio Tools para el desarrollo de aplicaciones basadas en Windows Al igual que con cualquier otra aplicación en .NET, se pueden crear aplicaciones basadas en Windows en un editor de texto, hacer llamadas a métodos y clases, compilar la aplicación en la línea de comandos y distribuir la aplicación ejecutable resultante. También se puede usar Visual Studio, cuando se utiliza para crear aplicaciones basadas en Windows, se crea esencialmente la misma aplicación que podría crearse escribiendo manualmente el código. La ventaja de utilizar Visual Studio reside en que proporciona herramientas que pueden conseguir que el desarrollo de aplicaciones sea más rápido, fácil y confiable. A continuación se enumeran y describen algunas de las herramientas de desarrollo de aplicaciones basadas en Windows más importantes: 

Diseñadores visuales para formularios Windows



Diseñadores visuales para Windows Presentation Foundation







Editores de código inteligentes que incluyen la finalización de instrucciones, la comprobación d la sintaxis y otras características del IntelliSense. Compilación y depuración integradas Herramientas de administración de proyectos para la creación y administración de archivos de aplicación, incluida la implementación en servidores de intranet o Internet.

Diseñadores visuales para formularios Windows Permite agregar controles a un formulario, organizarlos y escribir el código de sus eventos. El uso de este diseñador nos permitirá: 









19

Agregar componentes, controles de datos o controles basados en Windows a un formulario. Hacer doble clic en el formulario del diseñador y escribir código en el evento Load de ese formulario, o hacer doble clic en un control del formulario y escribir código para el evento predeterminado del control. Modificar la propiedad Text de un control seleccionado. Ajustar la ubicación del control seleccionado moviéndolo con el ratón o con las teclas de dirección. De forma similar, permite ajustar la ubicación con más precisión utilizando las teclas de dirección y CTRL. Por último, también se puede ajustar el tamaño utilizando las teclas de dirección y MAYÚS. Seleccionar varios controles utilizando MAYÚS+ clic o CTRL + clic, el primer control seleccionado es el control dominante al alinear o manipular el tamaño. Si se utiliza CTRL + clic, el último control seleccionado es el dominante; por lo tanto, el control dominante cambia cada vez que se agrega un nuevo control. También se pueden seleccionar varios controles haciendo clic en el formulario y arrastrando un rectángulo de selección que rodee los controles que se desean seleccionar.

El diseñador de Windows Forms proporciona una solución de desarrollo rápida para la creación de aplicaciones basadas en Windows. En él se realiza el diseño visual de formularios basados en el cliente. A continuación se muestra el área de diseño de las aplicaciones Windows Forms.

Ilustración 1: Área de diseño de aplicaciones Windows Forms

Diseñadores visuales de Windows Presentation Foundation El diseñador de WPF (Windows Presentation Foundation) proporciona compatibilidad de diseño visual para crear aplicaciones WPF y también en Silverlight. Para construir las interfaces de usuario de las aplicaciones, hay que arrastrar los controles del Cuadro de herramientas y establecer las propiedades en la venta de Propiedades. Incluso se pueden editar directamente en el código XAML, en el editor XAML. En la siguiente ilustración se muestra el área del diseñador WPF y algunas de sus ventanas auxiliares.

Ilustración 2: Área de diseño para aplicaciones Windows Presentation Foundation

20

Vista de diseño La vista de diseño proporciona una superficie de diseño visual para compilar los controles y aplicaciones WPF. Muestra una presentación del XAML que hay actualmente en la vista XAML. Cuando se cambian los controles en la superficie de diseño, la vista XAML se actualiza para reflejar los cambios. La vista de diseño proporciona muchas características para organizar los controles en la ventana o en la página de su aplicación WPF. A continuación se muestra una ilustración con algunas de las características de la vista de Diseño.

Ilustración 3: Área de diseño para aplicaciones Windows Presentation Foundation Veamos entonces, una pequeña descripción de estas características: 

Zoom: El control Zoom permite controlar el tamaño de la superficie de diseño. Puede hacer

zoom desde 10% hasta 20x. El valor de zoom se guarda en el archivo .suo de la solución. 

Panorámica: Cuando se aplica el zoom a la superficie de diseño y aparece una barra de des-

plazamiento horizontal o vertical, puede aplicar la panorámica para ver las partes de la superficie de diseño que están fuera de la pantalla. Mantenga presionada la barra espaciadora y, a continuación, arrastre la superficie de diseño para aplicar la panorámica. 

Ajustar a la vista: El botón Ajustar a la vista permite ajustar el tamaño de la superficie de di-

seño a la pantalla disponible en la vista de diseño. Esto resulta útil si ha hecho zoom para acercarse o alejarse mucho. 

Raíles de la cuadrícula: Los raíles de la cuadrícula se usan para administrar las filas y colum-

nas en un control Grid. Puede crear y eliminar columnas y filas, y puede ajustar el alto y el ancho relativos. 

Líneas de la cuadrícula: Las líneas de la cuadrícula se usan para controlar el ancho y alto de

las columnas y filas de un objeto Grid. Para agregar una nueva columna o fila, haga clic en los raíles situados encima y a la izquierda de Grid.

21



Indicadores de línea de cuadrícula: Un indicador de línea de cuadrícula aparece como un

triángulo en el raíl de la cuadrícula. Al arrastrar un indicador de línea de cuadrícula o la propia línea de cuadrícula, el ancho o el alto de las columnas o filas adyacentes se actualiza al mover el mouse. 

Icono de desplazamiento: Un icono de desplazamiento aparece en la parte superior izquier-

da de un control de panel seleccionado y permite mover el panel. Haga clic en el icono de desplazamiento y arrastre el control hacia la posición deseada en la superficie de diseño. 

Asas de ajuste d e tamaño: Las asas de ajuste de tamaño aparecen en los controles seleccio-

nados y permiten cambiar el tamaño del control. Cuando se cambia el tamaño de un control, normalmente aparecen valores de ancho y alto para ayudar a ajustar el tamaño del control con exactitud. 

Líneas del margen: Los márgenes representan la cantidad de espacio fijo comprendido entre

el borde de un control y el borde de su contenedor. Establezca los márgenes de un control haciendo clic en las líneas del margen. 

Códigos auxiliares de margen: Un código auxiliar de margen aparece en un control seleccio-

nado cuando el margen de este está establecido en 0.Haga clic en el código auxiliar de margen para establecer una distancia de margen hasta el borde correspondiente del contenedor. 

Guías de alineación: Las guías de alineación ayudan a alinear los controles entre sí. Si están

habilitadas, al arrastrar un control en relación con otros controles, las guías de alineación aparecen cuando los bordes y el texto de algunos controles están alineados horizontal o verticalmente. 

Barra de información: La barra de información aparece en la parte superior de la vista de di-

seño y muestra información sobre cómo presentar los problemas en dicha vista. En algunos casos, puede hacer clic en la barra de información para obtener información adicional sobre el problema. 

Barra de tamaño: Al mover el puntero del mouse sobre un raíl de la cuadrícula para un con-

trol Grid que tiene dos o más columnas o filas, aparece la barra de tamaño fuera del raíl. La barra de tamaño permite establecer las opciones de tamaño fijo, proporcional y automático para las filas y las columnas de Grid. 

Etiqueta de tamaño de raíz: La etiqueta de tamaño de raíz aparece en la parte inferior dere-

cha de la ventana en la vista de diseño cuando la ventana está seleccionada. Dicha etiqueta permite alternar el tamaño raíz de la ventana entre automático y fijo.

Vista XAML El lenguaje XAML proporciona al desarrollador un vocabulario declarativo, que está basado en XML, para especificar la interfaz de usuario de una aplicación. El diseñador de WPF proporciona a su vez una vista XAML y una vista de diseño de manera sincronizada. La vista XAML incluye IntelliSense, formato automático, resaltado de sintaxis y navegación por etiquetas. A continuación se muestra en una ilustración un ejemplo de algunas de las características del área XAML.

22

Ilustración 4: Área XAML para aplicaciones Windows Presentation Foundation Al igual que en el área de diseño, vamos a describir algunas de estas características: Barra de vista en dos paneles: La barra de vista en dos paneles permite controlar los tamaños relativos de la vista de diseño y la vista XAML. También puede intercambiar las vistas, especificar si la vista en dos paneles es horizontal o vertical y contraer cualquiera de las vistas 



IntelliSense de extensiones de marcado: Además de IntelliSense de lenguaje estándar, la vis-

ta XAML admite IntelliSense para extensiones de marcado. Al escribir una llave de apertura ({) en la vista XAML, IntelliSense muestra las extensiones de marcado disponibles. Al seleccionar una extensión de marcado en la lista, IntelliSense muestra los atributos disponibles. 

Explorador de etiquetas: El explorador de etiquetas aparece bajo la vista XAML y permite

moverse a cualquier etiqueta primaria de la etiqueta actualmente seleccionada en la vista mencionada. Al mover el puntero del mouse sobre una etiqueta en el explorador de etiquetas, se muestra una vista previa en miniatura de ese elemento. 

Zoom: El control Zoom permite controlar el tamaño de la vista XAML. Puede usar el zoom

desde 20% hasta 400%.

Entender Windows Forms Windows Forms fue el primer marco de trabajo para las interfaces de usuario que se construían en .NET para aplicaciones basadas en Windows. En Windows Forms, un formulario es una superficie visual en la cual podemos mostrar información al usuario. Normalmente construimos aplicaciones Windows Forms añadiendo controles al formulario y respondiendo a las acciones del usuario usando eventos como el clic del ratón o cuando se presiona alguna tecla. Las características clave de los Windows Forms son las siguientes: Controles IU 

23



Configuración de aplicación



Gestión de recursos



Sistema de cuadros de diálogo



Dibujo e Impresión.



Enlace a datos



Operaciones Multihilo.



Implementación de funciones.

Arquitectura de Windows Forms Windows Forms expone su modelo de programación mediante el uso de código administrado basado en el .NET Framework 4.Windows Forms consta de dos ensamblados principales: 

System.Drawing:

El espacio de nombres System.Drawing proporciona acceso a la funcionalidad básica de los gráficos GDI +. La funcionalidad avanzada se proporciona en el ensamblado System.Drawing.Drawing2D, y en el espacio de nombres System.Drawing.Text. La clase Graphics proporciona métodos para dibujar en la pantalla. Las clases como Rectangle y Point encapsulan lasprimitivas GDI +.La clase Pen se utiliza para dibujar líneas y curvas, mientras que las clases derivadas de la clase abstracta Brush se utilizan para rellenar el interior de las formas. 

System.Windows.Forms:

El espacio de nombres System.Windows.Forms contiene clases para crear aplicaciones basadas en Windows que aprovechar al máximo las características de interfaces de usuario ricas disponibles en el sistema operativo Microsoft Windows.

Entender Windows Presentation Foundation WPF es el sistema de presentación de próxima generación para la creación de aplicaciones cliente en el sistema operativo Windows. Usted puede utilizar WPF para crear una gama de aplicaciones basadas en Windows, desde un simple procesador de texto o un reproductor. El núcleo de WPF es un motor de representación independiente de la resolución y basados en vectores que aprovechan el hardware. Mediante el uso de WPF, puede crear tanto aplicaciones autónomas, y alojadas en explorador. Las características principales de esta nueva tecnología son las siguientes: XAML basada en interfaces de usuario. 

24



Enlace a datos



Gráficos avanzados en 2 dimensiones a través de vectores y una resolución independiente.



Gráficos en 3 dimensiones



Multimedia



Animación



Documentación e impresión



Procesamiento de acciones a través de comandos y eventos enrutados.



Interoperabilidad con controles Windows Forms.

El diseño dinámico es una característica importante que ofrece WPF. Esta característica permite interfaces de usuario escalables y también proporciona un excelente soporte para empresas y las consideraciones de diseño tales como la globalización y la localización. La localización está cubierta con mayor detalle más adelante.

Arquitectura de WPF WPF expone su modelo de programación mediante el código manejado en el Framework de .NET 4. WPF consiste en tres componentes: 

PresentationFramework



PresentationCore



Milcore

Tanto PresentationFramework como PresentationCore son componentes gestionados; milcore es un componente no gestionado. La interfaz de la aplicación Microsoft DirectX ® de programación (API) permite todas las manipulaciones de visualización en WPF y proporciona hardware eficiente y renderización de software. El componente milcore está escrito en código no administrado para ofrecer un rendimiento mejorado y una estrecha integración con el motor de DirectX. PresentationFramework y PresentationCore proporciona todas las clases y APIs que usan sus aplicaciones. En WPF se pueden llevar a cabo dos tipos de aplicaciones basadas en Windows: Aplicaciones de navegador XAML y aplicaciones stand-alone.

Aplicaciones de navegador XAML Las Aplicaciones del explorador XAML (XBAPs) combinan las características de aplicaciones web y aplicaciones cliente enriquecidas. Al igual que las aplicaciones web, las aplicaciones XBAP se pueden implementar en un servidor web e iniciarse desde Internet Explorer o Firefox. Al igual que las aplicaciones cliente enriquecidas, las aplicaciones XBAP pueden aprovechar las capacidades de WPF. El desarrollo de aplicaciones XBAP también es similar al desarrollo de aplicaciones cliente enriquecidas. En este tema se proporciona una introducción simple, de alto nivel, al desarrollo de aplicaciones XBAP y se describen las diferencias entre el desarrollo de aplicaciones XBAP y el desarrollo de aplicaciones cliente enriquecidas estándar. Las aplicaciones de explorador XAML (XBAPs) se acerca al modelo de los controles tradicionales que se basan en Microsoft ActiveX ® o al Modelo de componentes de objetos que se alojan en un explorador Web. Se utiliza este tipo de aplicación cuando la aplicación se puede ejecutar con permisos limitados, cuando un navegador puede alojar la aplicación, y cuando una distribución simplificada y modelo de actualización es un objetivo primordial. Al compilar una aplicación XBAP, el resultado incluye los tres siguientes archivos:

25

Archivo

Descripción

Ejecutable (.exe)

Contiene el código compilado y tiene la extensión .exe

Manifiesto de aplicación (.manifest)

Contiene los metadatos asociados a la aplicación y tiene la extensión .manifest

Manifiesto de implementación (.xbap)

Este archivo contiene la información que ClickOne emplea para implementar la aplicación y tiene la extensión .xbap

Tabla 1: Archivos de una aplicación XBAP La implementación de aplicaciones XBAP se realiza en un servidor web, por ejemplo Servicios de Microsoft Internet Information Services (IIS) 5.0 o versiones posteriores. No es necesario instalar .NET Framework en el servidor web, pero sí tiene que registrar las extensiones de nombre de archivo y los tipos Extensiones multipropósito de correo Internet (MIME) de WPF. Para preparar la aplicación XBAP para la implementación, hay que copiar el archivo .exe y los manifiestos asociados al servidor web. Crear una página HTML que contenga un hipervínculo para abrir el manifiesto de implementación, que es el archivo que tiene la extensión .xbap. Cuando el usuario haga clic en el vínculo al archivo .xbap, ClickOnce administrará automáticamente los mecanismos de descarga e inicio de la aplicación. También puede hospedar una aplicación XBAP en el marco de una página web. Un aspecto importante del rendimiento de una aplicación XBAP es su tiempo de inicio. Si una aplicación XBAP es la primera aplicación de WPF que se carga, el tiempo de inicio en frío puede ser de diez segundos o más. Esto se debe a que WPF representa la página de progreso, y es preciso iniciar en frío tanto el CLR como WPF para mostrar la aplicación. A partir de .NET Framework 3.5 SP1, el tiempo de inicio en frío de una aplicación XBAP se reduce mostrando una página de progreso no administrada al principio del ciclo de implementación. Además, la simultaneidad mejorada de la secuencia de descarga de ClickOnce reduce el tiempo de inicio en hasta un diez por ciento. Una vez que se ha efectuado la descarga y validación de manifiestos de ClickOnce, se inicia la descarga de la aplicación y la barra de progreso empieza a actualizarse.

Windows Forms VS Windows Presentation Foundation Como se ha comentado anteriormente dos tecnologías cliente Windows están disponibles para el diseño de aplicaciones Windows en el Framework de .NET. Cuando hay más de una única opción, la pregunta de qué tecnología elegir puede surgir. Para Windows Forms y WPF, la respuesta dependerá de varios factores. Cuando se inicia el diseño y el desarrollo de una nueva aplicación que se dirige a la plataforma Windows, se tienen tres opciones: Windows Forms 



26

WPF



Una mezcla entre Windows Forms y WPF

Windows Forms es una tecnología madura que tiene un enfoque en formularios sobre los datos. El hecho es que ser una plataforma madura implica que múltiples controles y recursos están disponibles para usarlos durante las fases de diseño y de desarrollo. Los formularios Windows tiene una amplia gama de controles para la carga y visualización de datos tabulares; metarchivos para el renderizado de gráficos, trabaja con calendarios, fechas y horas, y un proporciona un fácil acceso a los cuadros de diálogo. Estas características, combinadas con el desarrollo rápido de aplicaciones (RAD), y las herramientas de apoyo como Microsoft Visual Studio nos permiten desarrollar aplicaciones LOB enlazadas a datos de forma rápida y eficiente mediante el uso de formularios Windows Forms. Por otra parte, WPF permite crear visualmente aplicaciones ricas e interactivas que podemos encontrarlas difícil de construir mediante el uso de formularios Windows debido a la dependencia de los formularios de Windows en GDI +. WPF utiliza gráficos y algoritmos basados en vectores que proporcionan alta calidad, efectos visuales independientes de la resolución, que hacen muy adecuado para WPF cualquier aplicación gráfica orientada, tanto para gráficos 2-D y gráficos en 3-D. WPF también tiene un excelente soporte para medios de comunicación y el procesamiento de imágenes. WPF tiene una amplia gama de controles, además de una fuerte comunidad de controles de terceros, que le permiten alterar completamente el aspecto de la aplicación. De esta manera, usted puede construir aplicaciones de alta calidad y atractivas a la vista. WPF es una plataforma muy adecuada para cualquier aplicación exigente en los aspectos visuales que también pueden requerir visualizaciones de datos, contenido de texto complejo y dinámico en cuanto a experiencias interactivas, o donde usted puede exi gir un diseño personalizado. Ahora bien, podemos darnos cuenta que si la elección de la plataforma no es mutuamente excluyente; implica que la elección no es simplemente Windows Forms o WPF. Un enfoque sensato para el desarrollo podría ser el uso de ambas tecnologías en una misma solicitud. Los formularios Windows pueden alojar componentes WPF y WPF puede alojar los componentes de Windows Forms. Las dos plataformas tienen diferentes puntos fuertes y pueden complementarse entre sí. Usted puede tener una inversión existente en Windows Forms, en cuyo caso, es posible que prefieran aprovecharla desde WPF, en lugar de volver a escribir toda la aplicación para tomar ventaja de las características de interacción gráfica y de procesamiento de texto que WPF proporciona. Es posible que desee crear una nueva aplicación mediante el uso de WPF y combinarla con su inversión en los actuales controles de Windows Forms.

Elegir la tecnología cliente apropiada Hay múltiples factores a tener en cuenta cuando elegimos la tecnología cliente Windows que queremos aplicar en nuestros desarrollos. Podemos elegir: 





Windows Forms si tenemos una aplicación Windows Forms existente o estamos desarrollando una aplicación típica de formulario de datos, especialmente si estamos buscando una tecnología madura que tiene ya unos buenos pilares. Añadir WPF a nuestro proyecto si tenemos ya una aplicación en Windows Forms que podría mejorarse añadiendo algunas ventajas de WPF. WPF si estamos desarrollando una nueva aplicación donde los siguientes aspectos son factores importantes en nuestra aplicación:

o

27

Experiencia del usuario

o

Una interfaz a medida o personalizada

o

Uso de gráficos de alta calidad y renderizado del texto.

Patrones Arquitectónicos Hay múltiples patrones de diseño para usar en los diseños y construcciones de nuestras aplicaciones basadas en Windows. Es importante entender que problemas de diseño se solucionan con los patrones y cómo pueden ayudarnos a desarrollar nuestras aplicaciones. Los patrones de diseño tienden a ser descriptivos en términos abstractos y genéricos; Por lo tanto, es igualmente importante para nosotros ser conscientes de que patrones de diseño están disponibles y donde podemos encontrar implementaciones de referencia de dichos patrones.

Patrones de Diseño Podemos usar patrones de diseño como una manera formal de documentar una solución para un problema. Un patrón debería explicar un problema común en términos abstractos, presentando una solución al problema, también en términos abstractos, y después describir cuando se debe aplicar dicho patrón. Hay múltiples patrones que podemos encontrar beneficiosos en nuestras aplicaciones. Los patrones suelen ser clasificados en varias categorías tales como los patrones creacionales, patrones estructurales, patrones de comportamiento y patrones de presentación.

Patrones en el Framework de .NET El Framework de .NET utiliza muchos patrones, por ejemplo, el patrón Singleton es un patrón creacional popular que se utiliza en muchos lugares. NET Framework. Este modelo asegura que una clase tiene sólo una instancia y tiene un punto de acceso global. Es posible que haya visto este patrón cuando se utiliza la clase de aplicaciones de WPF, como muestra el siguiente ejemplo de código. var app= Application.Current;

Código 1 La propiedad Current sirve de punto de acceso global y la clase de Application garantiza que habrá una instancia única para toda la aplicación. Si has hecho cualquier desarrollo Web, usted habrá visto que la clase HttpContext, que proporciona también una propiedad Current que proporciona un punto de acceso global con las garantías de la existencia de una sola instancia. Sin embargo, este modelo tiene una debilidad, si la testabilidad es importante para su desarrollo. Las clases que implementan el patrón Singleton son generalmente difíciles de probar y son difíciles en pruebas, por lo tanto, debe evitar este patrón, si la capacidad en cuanto a pruebas sea un objetivo primordial de su diseño. Otro patrón dominante en el Marco. NET es el patrón Observer, que es un patrón de comportamiento. Este modelo define la manera de crear una dependencia de uno-a-muchos entre objetos de modo que cuando un objeto cambia de estado, todos sus o bjetos dependientes sean notificados de la actualización. Los precedentes a los patrones de Diseño vienen del campo de la Arquitectura, Christopher Alexander a finales de los 70 escribe varios libros acerca del urbanismo y la construcción de edificios, y se plantea reutilizar diseños ya aplicados en otras construcciones que cataloga como modelos a seguir. Crristopher da la siguiente definición de patrón: “ Cada patrón describe un problema que ocurre una y otra vez en nuestro entorno, para describir después el núcleo de la solución a ese problema, de tal

28

manera que esa solución pueda ser usada más de un millón de veces sin hacerlo ni siquiera dos veces de la misma manera”.

Por lo que podríamos definir los patrones de diseño como la forma de reutilizar la experiencia de los desarrolladores, para ello se clasifican y se describen las formas de solucionar los problemas que ocurren de forma frecuente en el desarrollo. Los patrones de diseño se pueden clasificar por su propósito o por su ámbito, veamos entonces las diferencias:

Según su propósito 1. Patrones de Creación: Tratan la creación de las instancias 2. Patrones Estructurales: Tratan la relación entre clases, la combinación entre clases y la for-

mación de estructuras de mayor complejidad. 3. Patrones de Comportamiento: Tratan la interacción y cooperación entre clases

Según su ámbito 1. Patrones de Clase: Basados en la herencia de clases 2. Patrones de Objeto: Basado en la utilización dinámica de objetos

A continuación se muestra una tabla con los patrones según su propósito y su ámbito:

Propósito

Ámbito

Creación

Estructural

Comportamiento

Clase

Factory Method

Adapter

Interpreter Template Method

Objeto

Abstract Factory Builder Prototype Singleton

Adapter Bridge Composite Decorator Facada Flywight Proxy

Chain of Responsability Command Iterator Mediator Memento Observer State Strategy Visitor

Tabla 2: Tabla con los patrones de diseño disponibles A continuación se muestra la plantilla para la definición de los patrones: Nombre Propósito

29