Desarollo de Aplicaciones Windows Con WPF 4.0 (Ejemplo)
30
1 Desarrollo de aplicaciones Windows con WPF 4.0 Aroa Solana Ejemplo de texto
Transcript of Desarollo de Aplicaciones Windows Con WPF 4.0 (Ejemplo)
1
Desarrollo de aplicaciones Windows
con WPF 4.0
Aroa Solana
Ejem
plo
de te
xto
Sinopsis Durante muchos años, el desarrollo de aplicaciones de escritorio para el sistema ope-rativo Windows ha hecho uso de los tradicionales Formularios (Windows Forms), adaptándose a las nuevas necesidades de negocio de las empresas y a las funcionali-dades del propio sistema. Es ahora, con la llegada de .NET Framework 4.0 y Visual Studio 2010, cuando Micro-soft ha decidido darle una nueva vuelta de tuerca a este tipo de desarrollos con Win-dows 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 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 Technolo-gy 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 Certi-fied 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 Win-dows, Web, ADO, Distribuidas, WPF, WCF, WWF, Silverlight y UML, por otra parte imparte formación en administración de bases de datos SQL Server y desarrollo de bases de datos SQL Server, tanto en 2005 como en 2008. Además posee experiencia en J2SE y J2EE. Dentro de la gestión de procesos posee la certificación ITIL V2 Founda-tions.
Ejem
plo
de te
xto
Luarna Desarrollo de aplicaciones Windows con WPF 4.0 © Aroa 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 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. Di-ríjase a CEDRO (Centro Español de Derechos Reprográficos, www.cedro.org) si necesita fotocopiar, escanear o hacer copias digitales de algún fragmento de esta obra.
Ejem
plo
de te
xto
Ej
empl
o de
text
o
Desarrollo de aplicaciones Windows con WPF 4.0
Aroa Solana Ruiz
Ejem
plo
de te
xto
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.
Ejem
plo
de te
xto
7
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 Ejem
plo
de te
xto
8
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 Ejem
plo
de te
xto
9
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 Ejem
plo
de te
xto
10
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 Ejem
plo
de te
xto
11
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 Ejem
plo
de te
xto
12
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 Ejem
plo
de te
xto
13
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 Ejem
plo
de te
xto
14
Eventos ................................................................................................................................... 418
Caso de Uso ................................................................................................................................... 425
Ejem
plo
de te
xto
15
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 su-pone 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 Micro-soft, 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 Visual 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ámi-cos 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 crea-ció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 carac-terí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 ayu-das 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 nues-tros ajustes favoritos de colores, editor de código, organizació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 Data-Tips 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:
Todas las llamadas destinadas y procedentes de un método, una propiedad o un constructor se-leccionados. Ejem
plo
de te
xto
16
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 reali-zan 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 ins-trucciones 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 ondula-do 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 nove-dades 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; To-olStrip, 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 formula-rio 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 inde-pendientes 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, mul-timedia, 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. Ej
empl
o de
text
o
17
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ña-dos 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 obje-tivo 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 Frame-work 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 pre-sente 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.
Ejem
plo
de te
xto
18
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, desta-car que las aplicaciones Windows que están creadas mediante el Framework de .NET ofrecen múlti-ples beneficios. Podemos acceder a servicios del sistema operativo y tomar ventaja de otros benefi-cios que proporcionan los entornos de ejecución. Podemos devolver datos para aplicaciones Win-dows 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 infor-mació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.
Ejem
plo
de te
xto
19
Visual Studio Tools para el desarrollo de aplicaciones ba-sadas 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 co-mandos 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 descri-ben algunas de las herramientas de desarrollo de aplicaciones basadas en Windows más importan-tes:
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á:
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 di-recció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 seleccio-nado 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 hacien-do clic en el formulario y arrastrando un rectángulo de selección que rodee los controles que se desean seleccionar. Ejem
plo
de te
xto
20
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 clien-te. 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 vi-sual 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 propie-dades 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 ven-tanas auxiliares.
Ilustración 2: Área de diseño para aplicaciones Windows Presentation Foundation Ejem
plo
de te
xto
21
Vista de diseño La vista de diseño proporciona una superficie de diseño visual para compilar los controles y aplica-ciones 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 carac-terí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 su-perficie 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. Ejem
plo
de te
xto
22
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 pro-pia 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 de 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 mar-gen 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 ver-ticalmente.
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. Ej
empl
o de
text
o
23
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, es-pecificar 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 selec-cionar 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 etique-tas, 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
Configuración de aplicación
Gestión de recursos Ejem
plo
de te
xto
24
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 basa-das 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 vecto-res que aprovechan el hardware. Mediante el uso de WPF, puede crear tanto aplicaciones autóno-mas, y alojadas en explorador. Las características principales de esta nueva tecnología son las siguientes:
XAML basada en interfaces de usuario.
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. Ejem
plo
de te
xto
25
Interoperabilidad con controles Windows Forms.
El diseño dinámico es una característica importante que ofrece WPF. Esta característica permite in-terfaces de usuario escalables y también proporciona un excelente soporte para empresas y las con-sideraciones 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 ren-derizació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 aplica-ciones. En WPF se pueden llevar a cabo dos tipos de aplicaciones basadas en Windows: Aplicaciones de na-vegador 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 aplica-ciones 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 aplica-ciones 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 explo-rador 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:
Ejem
plo
de te
xto
26
Archivo Descripción
Ejecutable (.exe) Contiene el código compilado y tiene la ex-tensión .exe
Manifiesto de aplicación (.manifest) Contiene los metadatos asociados a la apli-cación y tiene la extensión .manifest
Manifiesto de implementación (.xbap)
Este archivo contiene la información que ClickOne emplea para implementar la apli-cació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 Mi-crosoft 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 mani-fiestos 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 aplica-ció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 manifies-tos 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 Win-dows, se tienen tres opciones:
Windows Forms
WPF Ejem
plo
de te
xto
27
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 disponi-bles 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 desa-rrollo 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 encon-trarlas 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 propor-cionan 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 exigir un diseño personalizado. Ahora bien, podemos darnos cuenta que si la elección de la plataforma no es mutuamente excluyen-te; 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 quere-mos aplicar en nuestros desarrollos. Podemos elegir:
Windows Forms si tenemos una aplicación Windows Forms existente o estamos desarrollan-do una aplicación típica de formulario de datos, especialmente si estamos buscando una tec-nologí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 facto-res importantes en nuestra aplicación:
o Experiencia del usuario Ejem
plo
de te
xto
28
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 patro-nes 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 estructu-rales, 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 crea-cional 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 pun-to 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 comportamien-to. 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 objetos dependientes sean notificados de la ac-tualización. Los precedentes a los patrones de Diseño vienen del campo de la Arquitectura, Christopher Alexan-der 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 Ej
empl
o de
text
o
29
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:
Ámbito
Propósito
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 Ej
empl
o de
text
o
30
¿Qué hace?, ¿Cuál es su razón y propósito?, ¿Qué cuestión de diseño particular o problema que aborda? Sinónimos Motivación Escenario que ilustra un problema particular y cómo el patrón lo resuelve Aplicabilidad ¿En qué situaciones puede aplicarse? Estructura Diagrama de clases que ilustran la estructura Participantes Clases que participan y sus responsabilidades Colaboraciones Diagramas de interacción que muestran cómo colaboran los participantes Consecuencias ¿Cómo alcanza el patrón sus objetivos? Implementación Técnicas, heurísticas y consejos para la implementación Ejemplos de código Usos Conocidos Patrones relacionados
Abstract Factory • Propósito
Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar la clase concreta.
• Motivación
Un toolkit interfaz de usuario que soporta diferentes formatos: Windows, X-Windows,…
Ejem
plo
de te
xto
