visual studio 2010, net 4.0 y alm - bruno capuano

Visual Studio 2010 .NET 4.0 y

ALM

Actualízate desde la versión 2008

Bruno Capuano

VISUAL STUDIO 2010 .NET 4.0 Y ALM - ACTUALÍZATE DESDE LA

VERSIÓN 2008

No está permitida la reproducción total o parcial de este libro, ni su tratamiento informático, ni la transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, por registro u otros métodos, sin el permiso previo y por escrito de los titulares del Copyright. Diríjase a CEDRO (Centro Español de Derechos Reprográficos, www.cedro.org) si necesita fotocopiar o escanear algún fragmento de esta obra.

DERECHOS RESERVADOS © 2010, respecto a la primera edición en español, por Krasis Consulting, S. L.

www.Krasis.com

ISBN: 978-84-936696-4-5 Depósito Legal: M-13975-2010 Impreso en España-Printed in Spain

http://www.cedro.org/

http://www.krasis.com/

Prólogo “Todo mi agradecimiento y gratitud a Bruno. Es para mí un privilegio tenerlo como

amigo y consejero de un producto que desde hace más de tres años es parte importante

de mi vida. Seguro que vas a disfrutar descubriendo todas las novedades de Visual Studio 2010… que son muchas y variadas. Es un placer contar con colegas que

pongan tanta pasión para que los demás tengan un comienzo menos duro con cada

versión. Por todo esto, más su blog, su correr “pa ná”, su pasión por el código, etc..…. GRACIAS.”

Antonio Gómez Product Manager Visual Studio - Expression División de Desarrolladores y

Plataforma (DPE - Developer & Platform Evangelism) en Microsoft “Sin duda es difícil apasionarse con una herramienta de desarrollo. Pero cuando

ésta es Visual Studio, y quien transmite esa pasión es Bruno, la cosa cambia. Sobre el libro, qué puedo decir: nadie mejor que un apasionado con conocimientos

extraordinarios para conseguir que todos aprendamos a exprimir la herramienta con la que pasamos gran parte del día. Es un placer compartir eventos técnicos con Bruno,

es un placer leer su libro. Te puedo garantizar que uno no deja de sorprenderse con

las posibilidades de Visual Studio.”

Rodrigo Corral González

Software Architect - MVP Team System “Son ya muchas las charlas sobre Visual Studio, primero Team System, y ahora

ALM, compartidas con Bruno y con Rodrigo, Ahora, con Visual Studio 2010, mi amigo

Bruno lanza este libro que a buen seguro se convertirá pronto en una gran referencia

de la herramienta. Será lectura recomendada en todas nuestras charlas."

Luis Fraile INETA Speaker - MVP Team System

Agradecimientos No puedo dejar de agradecer a todas las personas que me han apoyado para que

escriba este libro. Las voy a ordenar por un criterio personal que es el que se me ha ocurrido en este momento para que sepan que les doy las gracias:

A mi chica, a Valentino y a Martina; que entre los 3 forman mi familia y han

aguantado noches y noches de un padre distante con la guitarra en la mano y con un Team Foundation Server 2010 delante del monitor en el ático.

A mi padre y a mi madre, que desde pequeño me compraron todos los libros que siempre pedí, y de esta forma hicieron que leer fuera una de mis pasiones (además esto sirve para confirmar que leer mucho no significa que puedas escribir bien)

A todos aquellos que me ayudaron con revisiones, material, etc.; que no es trabajo fácil llegar a un screenshot de Visual Basic 1. Así que gracias Juan Carlos González, Roberto Loreto, Gerardo Korndorffer, Jose Miguel Torres, Eduardo del Pozo, Sergio Vázquez y a todos los otros que me ayudaron tácitamente y que no los tengo en ningún correo.

A Avanade Spain que me permitió ser más flexible con mis horarios y poder jugar con Visual Studio 2010 entre proyecto y proyecto.

A Jose Manuel por darme la oportunidad de escribir un libro, y de compartir su experiencia conmigo durante el camino.

A todos aquellos que alguna vez me dieron un consejo, que me respondieron un mail, con los que compartí un café o una cerveza y que me ayudaron en los momentos medio raros en los que no sabía por dónde seguir.

Finalmente, además del sudor y lágrimas, creo que es interesante compartir las métricas del trabajo realizado para cerrar este libro.

Cerca de 16 litros de cerveza; principalmente botellines de Heineken de 330cl

tomados por la noche. Esto me sirve de excusa para los posibles errores que posea el libro.

Más de 20 litros de mate, solo y compartido en familia. He visto como se cambiaba la fecha de lanzamiento de Visual Studio 2010 al

12 de Abril, para que coincida con mi cumpleaños el 14 de Abril. He corrido más de 149 kilómetros y quemado más de 13000 calorías. Me han renovado como MVP de Team System por tercera vez.

vi

He visto cerca de 20 partidos de NBA de madrugada, mientras revisaba todo el material.

Me he dado un golpazo que me ha costado 8 puntos de sutura en la frente, mientras escuchaba un podcast de CMMI (reservados los comentarios).

He escrito partes del libro en 6 aeropuertos diferentes. He sufrido el cambio de nombre de Visual Studio a Visual Studio Ultimate,

gracias amigos de Seattle, tuve que revisar todo el libro. Ha nacido mi niña Martina el 13 de diciembre del 2009; que se ha sumado a

Valentino con sus 2 añitos, para que mis días sean lo menos productivo posibles súper happy happy.

Contenido

INTRODUCCIÓN Y UN POCO DE HISTORIA ................................................ xii

NOVEDADES EN EL IDE .............................................................................................. 1 1.- Novedades en el IDE .................................................................................................................. 1

1.1.- Rincón del Friki: ¿Por qué la Splash Screen no está desarrollada sobre WPF? 3 1.1.1.- Proceso para el control de las animaciones en la Splash Screen ................ 4 1.1.2.- Alpha Blending ......................................................................................................... 5 1.1.3.- Información en el Splash Screen .......................................................................... 6

1.2.- Rincón del Friki: ¿Cómo lanzar Visual Studio sin mostrar la Splash Screen? .... 6 2.- IDE Basado en Windows Presentation Foundation ............................................................ 6

2.1.- Tutorial: Agregando video online a nuestro editor de código fuente................ 8 2.2.- Tutorial: Trabajando con los nuevos tipos de selección en el IDE ................... 11

3.- La nueva Start Page ................................................................................................................... 14 3.1.- Tutorial: Personalizando la Start Page ...................................................................... 16

4.- Soporte MultiMonitor .............................................................................................................. 19 5.- Soporte para Multi Targeting .................................................................................................. 20

5.1.- Mejoras en la ventana de Agregar Referencias ...................................................... 22 6.- Búsqueda Inteligente ................................................................................................................. 23 7.- Resaltar Referencias .................................................................................................................. 24 8.- Consumir luego declarar ......................................................................................................... 25

8.1.- Tutorial: Utilización de Generate From Usage ...................................................... 26 9.- Jerarquía de Llamadas ............................................................................................................... 29 10.- Análisis de Código .................................................................................................................. 31 11.- IntelliTrace (Depurador Histórico) ................................................................................... 34

11.1.- Configuración de IntelliTrace ............................................................................. 37 11.2.- Cómo funciona IntelliTrace ................................................................................. 40 11.3.- Abriendo archivos de depuración de IntelliTrace ......................................... 42

12.- Depuración en Visual Studio 2010 ..................................................................................... 45 12.1.- Tutorial: Anclar ventanas de Watch en el IDE ............................................... 47 12.2.- Tutorial: Importar y Exportar BreakPoints ..................................................... 48

13.- Otras MEjoras en el IDE ....................................................................................................... 50 13.1.- Intellisense en el editor SQL en Visual Studio ................................................ 50 13.2.- Paneles para la depuración de múltiples hilos y tareas................................. 52 13.3.- Nuevo Intellisense y soporte para nuevos editores .................................... 54 13.4.- Desarrollando para Sharepoint .......................................................................... 55

NOVEDADES EN LOS LENGUAJES .............................................................................. 59 1.- Evolución de .Net Framework ............................................................................................... 59

1.1.- Soporte para lenguajes dinámicos ............................................................................. 59

viii Visual Studio 2010 .NET 4.0 y ALM Actualízate desde la versión 2008

viii

1.1.1.- Tutorial: Ejemplo de las ventajas en la utilización de dynamic. ................. 62 1.2.- Programación en Paralelo ............................................................................................ 64

1.2.1.- Tutorial: Ejemplo de programación con Parallel ........................................... 65 1.3.- Monitorización de Aplicaciones ................................................................................. 69

1.3.1.- Tutorial: Monitorización de aplicaciones a nivel de dominio de aplicación . 70 1.4.- Inicialización tardía de objetos (Lazy Initialization) ............................................... 72

1.4.1.- Tutorial: Creación de objetos con Lazy<T> .................................................. 72 1.5.- Ejecución In-Process Side-By-Side ............................................................................. 74 1.6.- Garbage Collector: Background GC ........................................................................ 75 1.7.- Code Contracts ............................................................................................................. 75 1.8.- Interoperabilidad ............................................................................................................ 77

1.8.1.- Tutorial: Trabajando con Excel en Visual Studio 2010 ................................ 78 1.9.- Covarianza y Contravarianza ...................................................................................... 80 1.10.- Colecciones y nuevas estructuras de datos .................................................... 82

1.10.1.- Tutorial: Trabajando con SortedSet<T> ......................................................... 84 1.11.- Gestión de Excepciones ....................................................................................... 86 1.12.- Gestión de Archivos ............................................................................................. 87 1.13.- Mejoras en Isolated Storage ................................................................................ 89 1.14.- Mejoras en el trabajo con hilos (Threads)....................................................... 89 1.15.- Managed Extensibility Framework ..................................................................... 90 1.16.- Otras mejoras en .Net Framework .................................................................. 91

2.- Novedades en C# 4.0 ............................................................................................................... 93 2.1.- Conceptos preliminares ............................................................................................... 93 2.2.- Introducción .................................................................................................................... 94 2.3.- Soporte para programación dinámica ....................................................................... 94 2.4.- Parámetros opcionales ................................................................................................. 96 2.5.- Mejoras en el trabajo con componentes COM ..................................................... 99

3.- Novedades en Visual Basic 2010 ......................................................................................... 100 3.1.- Un poco de historia .................................................................................................... 100 3.2.- Propiedades Auto-Implementadas ........................................................................... 101 3.3.- Inicializadores de Colecciones .................................................................................. 103 3.4.- Continuación de líneas implícita............................................................................... 105 3.5.- Soporte para expresiones Lambda multi línea ..................................................... 107 3.6.- Soporte para programación dinámica ..................................................................... 109

3.6.1.- Tutorial: Utilizando objetos dinámicos desde Visual Basic 2010 ............ 110 4.- Novedades en Visual C++ ..................................................................................................... 112

4.1.- Introducción .................................................................................................................. 112 4.2.- Soporte para MSBuild en proyectos de Visual C++ ........................................... 112

4.2.1.- Tutorial: Convirtiendo proyectos de Visual Studio 2008 a Visual Studio 2010 112 4.3.- Mejoras en el IDE, especialmente en Intellisense ................................................ 113

4.3.1.- Rincón del Friki: Funcionamiento del Intellisense en Visual C++ 2010 114 4.4.- Soporte para Restart Manager ................................................................................. 116 4.5.- Más velocidad en Link Time Code Generation.................................................... 116 4.6.- Másvelocidad en Profile Guided Optimization ..................................................... 117 4.7.- Otras mejoras en Visual C++ ................................................................................... 117

5.- Nuevo lenguaje: F# .................................................................................................................. 117 5.1.- Introducción a los lenguajes funcionales ................................................................ 117

Contenido ix

5.2.- Bienvenido F# ............................................................................................................... 120 5.3.- Trabajando con F#....................................................................................................... 121

5.3.1.- Tutorial: Primera aplicación en F# .................................................................. 129 5.3.2.- Tutorial: Utilizar tipos del CLR en F# ........................................................... 130 5.3.3.- Creando bibliotecas .Net en F# ...................................................................... 131

HERRAMIENTAS DE MODELADO ............................................................................. 137 1.- Herramientas de Modelado .................................................................................................. 137

1.1.- Introducción .................................................................................................................. 137 1.2.- Diseño basado en Modelos ....................................................................................... 140 1.3.- Herramientas de modelado: Domain-Specific Languages .................................. 141 1.4.- Herramientas para Arquitectos en Visual Studio 2010 ...................................... 145 1.5.- Resumen ......................................................................................................................... 146

2.- Layer Diagram .......................................................................................................................... 147 2.1.- Diseño en capas con Layer Diagram....................................................................... 148

2.1.1.- Tutorial: Crear un diagrama Layer Diagram ................................................ 154 2.2.- Asociaciones múltiples en Layer Diagram ............................................................. 160

2.2.1.- Tutorial: Realizar asociaciones múltiples en Layer Diagram .................... 161 2.3.- Asociaciones con WorkItems en Layer Diagram ................................................ 162

2.3.1.- Tutorial: Realizar asociaciones con WorkItems en Layer Diagram ....... 163 2.4.- Validación del diseño con Layer Diagram .............................................................. 165

2.4.1.- Tutorial: Validar una solución con un Layer Diagram ............................... 168 2.4.2.- Tutorial: Cómo verificar la validación de capas en un Build en TFS2010 ... 170 2.4.3.- Tutorial: Cómo activar la validación de capas en un Build en TFS2010 ..... 171 2.4.4.- Tutorial: Cómo agregar elementos personalizados en la Toolbox del Layer Diagram. 173

3.- Directed Graph Markup Language (DGML) ..................................................................... 176 3.1.- Introducción a DGML ................................................................................................. 176

3.1.1.- Tutorial: Mi primer diagrama DGML ............................................................. 179 3.1.2.- Tutorial: Utilizando la ventana de leyenda y selección en DGML .......... 181 3.1.3.- Tutorial: Agrupando nodos en DGML .......................................................... 183 3.1.4.- Tutorial: Realizando validaciones en DGML ................................................ 184 3.1.5.- Tutorial: Creando diagramas DGML desde un proyecto ......................... 186

4.- ArchiTecture Explorer ........................................................................................................... 188 4.1.- Introducción .................................................................................................................. 188 4.2.- Utilizando Architecture Explorer ............................................................................ 189

4.2.1.- Tutorial: Analizar una solución en vista de Clases ..................................... 193 4.2.2.- Tutorial: Analizar una solución en vista de Solución.................................. 194 4.2.3.- Tutorial: Aplicar filtros y disparar acciones entre columnas. .................. 194 4.2.4.- Tutorial: Generar gráficos DGML con la información de Architecture Explorer 195

4.3.- Consultas en Architecture Explorer: DGQL ....................................................... 197 4.3.1.- Tutorial: Guardar una consulta DGQL ......................................................... 198

5.- Análisis de Dependencias gráficos ....................................................................................... 199 5.1.- Generación de relaciones entre ensamblados ..................................................... 199 5.2.- Generación de relaciones entre Namespaces ...................................................... 199 5.3.- Generación de relaciones entre Clases ................................................................. 200

6.- Diseñadores UML .................................................................................................................... 201 6.1.- Introducción a UML .................................................................................................... 201 6.2.- Diagramas de Casos de Uso ..................................................................................... 204

x Visual Studio 2010 .NET 4.0 y ALM Actualízate desde la versión 2008

x

6.2.1.- Tutorial: Creando mi primer diagrama de Casos de Uso ........................ 206 6.3.- Diagrama de Actividades ............................................................................................ 208

6.3.1.- Tutorial: Crear un diagrama de actividad y relacionarlo con un caso de uso. . 209 6.4.- Diagrama de Componentes ...................................................................................... 211 6.5.- Diagrama de Clases (UML)........................................................................................ 211

6.5.1.- Tutorial: Generar código a partir de un diagrama de clases UML ......... 213 6.6.- Diagrama de Secuencia ............................................................................................... 216

6.6.1.- Tutorial: Crear un diagrama de secuencia UML a partir de los elementos

de un diagrama de clases UML. ...................................................................................... 217 6.6.2.- Tutorial: Crear un diagrama de secuencia UML a partir de código. ...... 218

6.7.- UML Model Explorer .................................................................................................. 220 6.7.1.- Tutorial: Utilizando el panel UML Model Explorer .................................... 221

TEAM FOUNDATION SERVER 2010 Y LA GESTIÓN DE PROYECTOS .......................... 223 1.- Novedades en TFS 2010 ........................................................................................................ 223

1.1.- Introducción .................................................................................................................. 223 1.2.- Team Project Collections .......................................................................................... 224

1.2.1.- Tutorial: Cómo detener un Team Project Collection y mostrar un

mensaje personalizado a los usuarios que acceden al mismo. ............................... 226 1.3.- WorkItems Jerárquicos .............................................................................................. 228

1.3.1.- Rincón del Friki: Pequeñas grandes mejoras cuando trabajamos con

WorkItem Queries ........................................................................................................... 231 1.3.2.- Tutorial: Trabajando con WorkItems jerárquicos en Visual Studio ...... 233 1.3.3.- Tutorial: Trabajando con WorkItems jerárquicos en Microsoft Project

235 1.4.- Mejoras en la definición y presentación de WorkItems .................................... 236 1.5.- Novedades en Source Control ................................................................................ 238

1.5.1.- Rincón del Friki: Cambio en el corazón del Source Control – Item Mode vs Slot Mode ... 242 1.6.- Integración con Microsoft Office ............................................................................. 243

1.6.1.- Tutorial: Trabajando con WorkItems jerárquicos en Excel ................... 246 2.- Instalacion y despliegue de TFS 2010 ................................................................................. 247

2.1.- Instalación de Team Foundation Server 2010 ...................................................... 247 2.2.- Administración de Team Foundation Server 2010 ............................................. 249 2.3.- Team Foundation Server Basic ................................................................................. 250 2.4.- Topologías de instalación de TFS 2010 .................................................................. 251

3.- TFS Build 2010 .......................................................................................................................... 253 3.1.- Introducción .................................................................................................................. 253 3.2.- Build Controllers y Build Agents ............................................................................. 254

3.2.1.- Rincón del Friki: TFS Build Service con soporte a procesos interactivos ...... 256 3.3.- Procesos de compilación basados en WF 4.0 ...................................................... 257 3.4.- Propiedades de las definiciones de compilación .................................................. 260

3.4.1.- Tutorial: Personalizando el formato del nombre de un Build ................. 263 3.5.- Analizando y trabajando con los resultados de las compilaciones .................. 264 3.6.- Test Impact Results ..................................................................................................... 267

3.6.1.- Tutorial: Utilizando Test Impact View ........................................................... 268 3.7.- Gated Check-in ............................................................................................................ 270

Contenido xi

3.7.1.- Rincón del Friki: ¿Cómo realizar un CheckIn que no dispare un proceso de

Integración Continua? ............................................................................................................ 272 4.- Gestionando proyectos con TFS 2010............................................................................... 273

4.1.- Introducción .................................................................................................................. 273 4.2.- Mejoras en MSF for Agile........................................................................................... 275 4.3.- Mejoras en MSF for CMMI ........................................................................................ 278 4.4.- Conclusión ..................................................................................................................... 282

NOVEDADES EN TESTING EN VISUAL STUDIO 2010 ............................................... 283 1.- Introducción .............................................................................................................................. 283 2.- Eliminar los escenarios “No-Repro” .................................................................................. 283 3.- Microsoft Test Manager ......................................................................................................... 285 4.- Coded UI TEsts ........................................................................................................................ 291

4.1.1.- Tutorial: Creación y lanzamiento de una prueba del tipo Coded UI Test ....... 294 5.- entornos de Pruebas Virtuales: Lab Management ........................................................... 295 6.- Conclusión ................................................................................................................................. 298

EL NUEVO MODELO DE LICENCIAS EN VISUAL STUDIO 2010 .................................. 301 1.- Introducción .............................................................................................................................. 301 2.- Productos por versión ........................................................................................................... 303

ÍNDICE ANALÍTICO .......................................................................................... 307

xii Visual Studio 2010 .NET 4.0 y ALM Actualízate desde la versión 2008

xii

Introducción y un poco de historia Las personas que nos dedicamos al desarrollo del software hemos visto como las

herramientas han evolucionado durante los últimos años. Hoy contamos con entornos de desarrollo (IDE) muy potentes, que no sólo permiten desarrollar aplicaciones, sino también permiten realizar otras tareas como depurar en entornos remotos, gestionar aplicaciones On the Cloud, verificar el estado de avance de un proyecto, y muchas otras funcionalidades que hacen que se pueda trabajar en un equipo de desarrollo.

Pero todo esto comenzó hace ya bastante tiempo cuando las herramientas simplemente permitían realizar 2 acciones básicas para un desarrollador: editar y compilar; luego teníamos en nuestro escritorio de trabajo, muchos diagramas, esquemas y bocetos que nos ayudaban a trabajar. Sobre esta base de 3 herramientas han crecido los IDEs hasta ser lo que conocemos actualmente.

Por ejemplo, hace ya más de 10 años, las herramientas con las que trabajaba un programador estaban orientadas exclusivamente a una función. Si necesitabas hacer aplicaciones Windows podías utilizar Visual Basic 6 y hacer aplicaciones muy velozmente. Si comenzábamos a pensar en capas y en aplicaciones web, pues nos tocaba crear componentes COM con Visual Basic, crear páginas ASP con Visual Interdev y seguramente utilizábamos una base de datos SQL 7 o Access como repositorio de datos. La gestión del versionado de código fuente la realizábamos con Visual Source Safe y hasta aquí ya voy contando 4 herramientas diferentes para trabajar en un proyecto.

Con la llegada de Visual Studio .Net, tuvimos un gran cambio en este aspecto: teníamos un único entorno de desarrollo para crear aplicaciones Windows, aplicaciones Web, aplicaciones para dispositivos móviles; e inclusive desde la interfaz de Visual Studio podíamos realizar otras tareas como acceder a los servicios de Windows, consultar el visor de eventos, y muchas más. El principal cambio fué la inclusión del .Net Framework (en su versión 1.0), una plataforma de desarrollo que nos permitía independizarnos del lenguaje de programación y poder utilizar el lenguaje que más se adapte a nuestros gustos para programar. A partir de este momento, el concepto de cómo desarrollar aplicaciones cambió radicalmente, pero sin embargo las herramientas seguían estando enfocadas a las tareas de un desarrollador.

Esto cambio con Visual Studio Team System 2005. En esta Release Microsoft hizo una apuesta muy fuerte y cambio el concepto clásico de herramientas de desarrollo. Visual Studio pasó a ser un conjunto de diferentes herramientas y las mismas se clasificaban por perfil, de esta forma existía una versión para programadores, otra para Testers, otra para arquitectos y una para administradores de base de datos. Obviamente el IDE seguía siendo la herramienta principal y dentro de la misma existían otras

Introducción y un poco de historia xiii

herramientas que eran compartidas por varios perfiles, pero se introdujo algo que realmente revolucionó la forma de trabajar: Team Foundation Server (TFS).

Team Foundation Server es el servidor de trabajo a través del cual las personas que integran un equipo de trabajo pueden colaborar entre sí. Y colaborar es algo más que compartir información; TFS se encarga del versionado de los archivos de código fuente, de la gestión de la configuración, se integra con Sharepoint para poder gestionar la documentación siempre tan necesaria en un proyecto, e inclusive incorpora un motor de compilación para poder automatizar las tareas de compilación. En realidad TFS puede llegar a realizar muchas otras tareas, gracias a un modelo de trabajo extensible, que permite que lo adaptemos a las necesidades puntuales de cada proyecto. Pero la mejor virtud que posee TFS es que toda la información que se recoge en las diferentes tareas, se almacena en una base de datos de DataWarehouse que luego puede ser explotada para analizar y cruzar esta información, por ejemplo para ver datos clásicos como la evolución de la cantidad de errores por Release, u otros más “raros” como la

cantidad de errores por horas trabajadas y los problemas que podemos tener por no tener una buena planificación de iteraciones.

Visual Studio Team System 2008 es una evolución de Visual Studio Team System 2005, porque si bien incorpora nuevas funcionalidades como la capacidad de poder trabajar con integración continua; los conceptos sobre los que trabaja la herramienta siguen siendo las mismos.

Aunque ¡ojo!, que durante todo este tiempo también ha madurado el .Net Framework, y después de 3.5 versiones, ha dejado de ser un Runtime de ejecución de aplicaciones, para ser una colección de herramientas para el desarrollo de aplicaciones: ADO.Net, Entity Framework, Silverlight, Windows Communication Foundation, ASP.Net MVC, etc.; uff no termino más.

BIENVENIDO VISUAL STUDIO 2010 Y ahora ha llegado Visual Studio 2010, que una vez más supone un cambio en la

forma en la que desarrollamos software. En este libro doy un recorrido por las mejoras que existen en .Net Framework 4.0 y en el IDE de Visual Studio 2010, e intento hacer hincapié en las novedades de esta versión: herramientas de modelado, la gestión de proyectos, las mejoras en el Build, etc. Pero claro, hay tanto material nuevo en Visual Studio 2010 que es imposible meter todo es un único libro, tal vez en el próximo o tal vez en una versión más extendida. Pero creo que si quieres conocer las principales novedades de Visual Studio 2010, estas páginas son un buen punto de partida.

Ahora que he terminado de crear el contenido y reviso esta introducción, realmente veo que tratar de escribir sobre Visual Studio 2010 es una tarea titánica. De la mayoría de los temas que comento en los capítulos del libro seguramente se escribirán varios libros, algunos ya están publicados como ASP.Net 4.0, y otros como Silverlight 4, Entity Framework 4.0, desarrollo para AZURE, etc.; verán la luz durante el año 2010.

Como soy una “persona práctica”, he decidido reemplazar páginas de texto sobre un

tema determinado con tutoriales. Es decir, para cada novedad o elemento que comento de Visual Studio 2010 + .Net 4.0, intento agregar un pequeño tutorial para demostrar esa funcionalidad. Así es que, entre una cosa y otra, hay más de 45 tutoriales que te permitirán, no solo leer sobre lo nuevo de esta versión, sino que además con un Visual

xiv Actualízate desde la versión 2008

Studio a mano, poder probarlo en pocos pasos. También he agregado muchas referencias a material externo en cada sección, que va desde un artículo de gestión de excepciones en C++ del año 2002 (¡fundamental!), hasta la documentación en línea de MSDN que todavía está por cerrarse para .Net 4.0 y Visual Studio 2010.

Finalmente, en algunas secciones especiales he creado un [Rincón del Friki] que apunta básicamente a escenarios de bajo nivel, a temas que no se tratan habitualmente o a pequeños consejos que siempre es útil conocer.

1

CAPÍTULO

En este capítulo daremos un repaso a las novedades que se han incorporado al entorno de desarrollo de Visual Studio 2010. Desde las novedades estéticas relacionadas con Windows Presentation Foundation y el nuevo modelo de extensibilidad, hasta algunas de las nuevas herramientas para desarrolladores que se han incorporado en esta versión.

1.- NOVEDADES EN EL IDE Para nosotros los desarrolladores o programadores, el entorno de desarrollo

integrado de Visual Studio (IDE: Integrated Development Environment,http://bit.ly/7Azaog) no ha cambiado mucho en los últimos años. La base del IDE es un área central de trabajo, una colección de menús y barras de herramientas; y una serie de paneles que es posible anclar (traducción libre de dock) y agrupar donde se publican funcionalidades propias de las herramientas internas de Visual Studio.

Por ejemplo la siguiente imagen muestra un pantallazo de Visual InterDev del año 1999 donde es posible ver que los conceptos de paneles, ventana de propiedades y zona central de trabajo se mantienen hasta nuestros días.

Novedades en el IDE

1

http://bit.ly/7Azaog

2 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

Figura 1.- IDE de Visual Interdev

La siguiente imagen muestra el IDE de Visual Studio Team Suite 2008 (10 años

después), en la misma se ha cargado la solución completa con el código fuente de Enterprise Library versión 4.1 (http://bit.ly/7BbAcB). Esta solución posee 42 proyectos y en la imagen se está editando el código fuente del gestor de recursos de tipo String. Si bien es posible notar diferencias, relacionadas con las ventanas de Windows, la base del IDE sigue siendo la misma.

Figura 2.- IDE de Visual Studio 2008

http://bit.ly/7BbAcB

Novedades en el IDE 3

Cuando desde el menú de programas de Windows, accedemos por primera vez al acceso de Visual Studio 2010 lo primero que llama la atención es el nuevo logo de Visual Studio donde se presenta el clásico símbolo de infinito (http://bit.ly/5tuGyt) de Visual Studio. En esta versión el logo de infinito ha perdido las formas rectas conectadas entre sí y ha pasado a ser una cinta continua con su base en colores azules. Luego se lanza la ventana de inicio (Splash Screen) y aquí ya vemos que los cambios son visibles desde el primer momento.

Figura3.-Splash Screen Visual Studio 2010

A continuación nos encontramos con un entorno de trabajo integrado

completamente diferente al que se nos presentaba desde Visual InterDev hasta Visual Studio 2008. En realidad los elementos del IDE son los mismos: barras de herramientas, menús y paneles; pero en la versión 2010 el IDE ha sido completamente rediseñado basado en WPF con lo que las capacidades de extensión y presentación aprovechan ahora toda la potencia de Windows Presentation Foundation.

1.1.- Rincón del Friki: ¿Por qué la Splash Screen no está

desarrollada sobre WPF?

Si bien todo Visual Studio 2010 está basado en Windows Presentation Foundation,

la Splash Screen está creada utilizando otras tecnologías. Este cambio ha sido obligado principalmente por cuestiones de rendimiento, basado en las siguientes premisas:

http://bit.ly/5tuGyt


La pantalla de inicio debe ser lo más rápida posible entre el momento que se lanza la aplicación y la Splash Screen aparece.

No se busca perder recursos dedicados a la aplicación en la Splash Screen, la misma solo debe dar la bienvenida al usuario.

Si se hubiese utilizado Windows Presentation Foundation en la implementación de la Splash Screen, hubiese sido necesario que se esperase para que se inicializase el CLR y el gestor de WPF para poder comenzar a pintar la Splash Screen. Este funcionamiento no se puede comparar con el rendimiento de aplicaciones directamente escritas en código nativo C++. Este es el motivo principal por el que se decidió crear la Splash Screen en C++. Esta sección está basada en un WebCast de Paul Currington sobre extensibilidad de Visual Studio, más información en http://bit.ly/5LMrpl.

1.1.1.- Proceso para el control de las animaciones en la

Splash Screen La Splash Screen en Visual Studio 2010 se desvanece suavemente durante el tiempo

en el que se puede ver la misma antes de lanzar el IDE de Visual Studio. Esta animación tarda aproximadamente 200 milisegundos que, según palabras de un ingeniero de rendimiento de Microsoft: "es una eternidad y debe ser aprovechado". Es por esto que durante los 200 milisegundos que tarda la Splash Screen en visualizarse, se da inicio a todo el proceso de control de interfaz de usuario de Visual Studio 2010 desde un subproceso en segundo plano. En el inicio de la aplicación, Visual Studio crea un subproceso dedicado, de baja prioridad, para cargar la imagen de la Splash Screen y luego aplica el efecto para ocultarlo con el efecto de desvanecimiento en la pantalla. Una vez que se realiza la intensificación, el subproceso se pega hasta la ventana principal está lista para mostrar, momento en el que se destruye la ventana de la Splash Screen y el subproceso se destruye tranquilamente.

Nota: Si se ejecuta Visual Studio 2010 en un equipo con un solo núcleo el

subproceso que controla la animación del Splash Screen no se crea, es el proceso principal de Visual Studio 2010 el que se encarga de todo el trabajo. En este caso, no hay animaciones de fundido ni de desvanecimiento, en cambio el Splash Screen aparece en la pantalla simplemente como una imagen. La animación también está desactivada en una sesión de escritorio remoto para ahorrar ancho de banda de la red.

http://bit.ly/5LMrpl


1.1.2.- Alpha Blending Una característica llamativa de la nueva Splash Screen está en el borde de la parte

inferior de la misma. Éste posee una curva que imita el logo de infinito de Visual Studio, asimismo en la imagen también se han redondeado esquinas superiores y se ha aplicado una suave sombra. Las curvas, sombra y anti-aliasing se obtienen ajustando el canal Alpha (que define la transparencia) de cada píxel de la imagen original.

Vamos por un poco de cultura general sobre Alpha Blending: el color de un píxel de la pantalla está determinada por sus valores de componente de color rojo, verde y azul (RGB, por sus siglas en inglés Red, Green and Blue). Variando los valores de cada componente o el "canal" se pueden crear millones de colores diferentes. Cuando todos los canales están apagados el resultado es un píxel negro, y al contrario cuando todos los canales están en su máxima intensidad, se muestra un píxel blanco. La intensidad de cada canal está representada por un número donde cero significa "off" y el valor máximo es la intensidad máxima posible. Así, por ejemplo, a partir de un píxel negro (todos los canales "off"), aumentando gradualmente el valor del canal rojo mostrará un píxel gradualmente más brillante y más brillante rojo. Normalmente, un número de 8 bits (byte) se utiliza para representar la intensidad, por lo que la intensidad máxima está representada por el número 255. Con tres canales, 3 bytes (24 bits) se necesitan para representar todos los colores posibles. La mayoría de los equipos actualmente son de 32 bits, lo que significa que registros internos y memoria trabajar más eficazmente cuando se trata de datos que son de 32 bits de longitud (un valor DWORD). Si utilizamos un valor DWORD para representar cada píxel, con sólo 24 bits utilizados para obtener información de color, eso nos dejar 8 bits de "información perdida" o "información no utilizada". Esos bits no utilizados en cada píxel son demasiado seductores para omitirlos. No se tardó mucho tiempo antes de que alguien tuviese una excelente idea: utilizar esos bits de repuesto.

El canal alfa utiliza esos 8 bits para representar el "Blending" para cada píxel - "PPA: per píxel Alpha". Cuando el píxel está pintado en la pantalla, se determina el "Blending" para ese pixel a través del valor alfa. Un valor alfa de cero indica un píxel completamente transparente - que no contribuye en absoluto a la imagen final. Un píxel totalmente opaco - uno que pinta completamente cualquier píxel subyacente - está representado por el máximo valor alfa de 255. Valores de alfa entre 0 y 255 representan contribuciones parciales. Un valor más alto de alfa significa una contribución más fuerte de los píxeles de la imagen. Ahora, en lugar de simplemente modelo RGB, tenemos un ARGB (A para Alpha), 32 bits por píxel (32bpp) imagen. Para la imagen de la Splash Screen de Visual Studio 2010, los bordes curvados y la sombra forman parte de la imagen original y se aprovechan las capacidades de Alpha Blending para difuminar la imagen sobre el área de trabajo. En el caso de los bordes suaves (por ejemplo con sus sombras), el canal alfa varía de píxel a píxel hasta difuminarse.

Toda la imagen se almacena en formato PNG (Portable Networks Graphics, http://bit.ly/6z8gdA). El formato PNG tiene compresión sin pérdidas y es compatible con un canal Alpha de 8 bits completo. La imagen es decodificada desde su formato de archivo PNG y se carga en memoria utilizando GDI +.

http://bit.ly/6z8gdA


1.1.3.- Información en el Splash Screen Pero esto no es todo, ya que la imagen final, incluye también más información: el

texto de la licencia de Visual Studio, el derecho de autor, el usuario que instaló el producto, entre otras. El texto está pintado en la imagen de base que se ha cargado en memoria utilizando GDI +. Una de las ventajas de utilizar GDI+ es que el mismo admite la inserción de texto con ClearType suavizado en la imagen. De esta forma también es posible dar soporte para múltiples culturas en el Splash Screen de Visual Studio

1.2.- Rincón del Friki: ¿Cómo lanzar Visual Studio sin

mostrar la Splash Screen?

En Visual Studio 2010 se ha respetado un parámetro que se aplica al ejecutable de

Visual Studio que se viene utilizando desde hace bastantes versiones [/nosplash]. Este parámetro indica a Visual Studio que se lance sin mostrar la Splash Screen.

2.- IDE BASADO EN WINDOWS PRESENTATION

FOUNDATION Más allá de una cuestión estética, la decisión de montar el IDE de Visual Studio

sobre Windows Presentation Foundation viene dada por una cuestión de fondo: mejorar la experiencia del usuario; en este caso de los diferentes perfiles que intervienen en el proceso de desarrollo. Una buena experiencia de usuario implica una mayor productividad, más efectividad y aumento de beneficios.

Por ejemplo, en los editores de código, el texto que se visualiza en los editores presenta una fuente y un tamaño determinado. Habitualmente cuando queremos cambiar el tamaño del texto en Visual es necesario acceder al menú [Tools // Options //

Environment // Fonts and Colors] y desde allí cambiar el tamaño del texto. La siguiente imagen muestra un ejemplo con el tamaño del texto en 8 pixeles y 72 pixeles en Visual Studio 2008.

Nota: Durante la instalación de Visual Studio, se genera la imagen de la Splash

Screen final creando la imagen de base con texto localizado, utilizando GDI +. La imagen se guarda como un archivo PNG almacenado como datos de programa en el equipo del usuario


Figura 4.- Cambio de tamaño en Visual Studio 2008

En Visual Studio 2010 ya tenemos la capacidad de poder configurar el Zoom

dinámicamente con lo que para cambiar el tamaño del texto que vemos en un editor, solo debemos presionar CTRL+ y con el botón central del mouse (la ruedita) podremos cambiar la visualización completa de nuestro editor. Pero esto tiene otras ventajas, al ser un dibujado vectorial el que presenta Windows Presentation Foundation, si aumentamos el nivel de Zoom a un 400% la calidad del texto que visualizamos no se degradará. Obviamente que hacer un zoom tan grande sobre texto no tiene sentido, pero en capítulos posteriores veremos cómo las nuevas capacidades gráficas han permitido que existan nuevos diseñadores gráficos y que el nivel de detalle que se visualice en los editores puede estar de acuerdo con el nivel de zoom con el que se esté trabajando.

Figura 5.- Cambio de Zoom en Visual Studio 2010

Además podemos seleccionar texto no solo en modo text, es decir línea a línea, sino

también en modo selección abierta (Box Mode). Esto permite que dentro del editor de código sea posible seleccionar una sección irregular y trabajar con la misma: por


ejemplo copiar el contenido al portapapeles o insertar texto en el mismo. En el nuevo IDE se han agregado nuevas características sobre estas funcionalidades:

La capacidad de seleccionar una línea de longitud cero.

La capacidad de editar múltiples líneas al mismo tiempo.

Estas funcionalidades se conocen como [Box Selection] y [Multi-Edit].

2.1.- Tutorial: Agregando video online a nuestro editor de

código fuente

El siguiente tutorial demuestra como agregar una ventana de video de Channel 9 al

editor de código de Visual Studio en la sección superior del editor, utilizando un elemento del tipo MediaElement (http://bit.ly/8maMGs) de Windows Presentation Foundation.

Para este ejemplo se requiere instalar el SDK de Visual Studio 2010, actualmente se puede descargar desde: http://bit.ly/8CduLT.

1. Abrir Visual Studio 2010.

2. Crear un nuevo proyecto a través de las opciones de menú [File / New /

Project]

3. En la lista de plantillas seleccionar [Installed Templates / Visual C# /

Extensibility / Editor Margin]

4. Definir el nombre del proyecto y la ubicación del mismo. En este caso llamaremos al proyecto [VS2010BookEditorMargin]

Figura 6.- Agregar nuevo proyecto

http://bit.ly/8maMGs

http://bit.ly/8CduLT


5. En el proyecto de extensibilidad podremos ver que el proyecto posee 2 clases principales: GreenMargin.cs y MarginFactory.cs.

Figura 7.- Estructura de Proyecto

6. Renombrar la clase GreenMargin por C9VideoMargin.

7. Modificar el código como en el siguiente ejemplo.

/// <summary>

/// A class detailing the margin's visual definition

/// including both size and content.

/// </summary>

class C9VideoMargin : Canvas, IWpfTextViewMargin

{

// The name of the margin

public const string MarginName = "C9VideoMargin";

// The IWpfTextView that our margin will be attached to.

private IWpfTextView _textView;

// A flag stating whether this margin has been disposed

private bool _isDisposed = false;

/// <summary>

/// Creates a <see cref="C9VideoMargin"/> for a given

/// <see cref="IWpfTextView"/>.

/// </summary>

/// <param name="textView">The <see cref="IWpfTextView"/>

/// to attach the margin to.</param>

public C9VideoMargin(IWpfTextViewtextView)

{

// Set the IWpfTextView

_textView = textView;

// Establish the background of the margin.

this.Height = 240;

this.ClipToBounds = true;

this.Background = new SolidColorBrush(Colors.Orange);


// add media element

MediaElement videoChannel9 = new MediaElement()

{

Source = new Uri

("http://mschnlnine.vo.llnwd.net/d1/ch9/1/8/3/0/5/4/VSTS08_ch9.wmv")

};

this.Children.Add(videoChannel9);

}

}

CheckPoint:El constructor de la clase es el encargado de decorar a la ventana de

edición de código con un nuevo visor de videos (basado en un MediaElement) y luego asociar al mismo la ruta de un video de Channel 9. En este caso un video de casi 20 minutos donde hago un recorrido por VSTS: Un paseo por Visual Studio Team System 2008.

8. Una vez agregado el decorador que en el margen del editor de código agregará el visor de video, es necesario modificar la clase MarginFactory para que agregue el decorador en la sección superior. El siguiente código muestra un ejemplo de la versión original modificada. En la línea 10 es posible ver como se define que el contenedor estará en la zona superior y también el color de fondo en naranja.

#region VS2010BookEditorMargin Factory

/// <summary>

/// Export a <see cref="IWpfTextViewMarginProvider"/>, which

/// returns an instance of the margin for the editor

/// to use.

/// </summary>

[Export(typeof(IWpfTextViewMarginProvider))]

[Name("C9VideoViewerBar")]

//Ensure that the margin occurs below the horizontal scrollbar

[Order(After = PredefinedMarginNames.HorizontalScrollBar)]

//Set the container to the bottom of the editor window

[MarginContainer(PredefinedMarginNames.Top)]

//Do this for all content types

[ContentType("text")]

[TextViewRole(PredefinedTextViewRoles.Interactive)]

internal sealed class MarginFactory : IWpfTextViewMarginProvider

{

public IWpfTextViewMargin

CreateMargin(IWpfTextViewHosttextViewHost,

IWpfTextViewMargincontainerMargin)

{

return new C9VideoMargin(textViewHost.TextView);

}

}

#endregion

9. Compilamos el proyecto para validar que no existan errores.

10. Una vez compilado el ejemplo, si se ejecuta el proyecto es posible ver cómo se levanta una nueva instancia de Visual Studio llamada entorno


experimental (Visual Studio Experimental Hive). Esta nueva instancia permite probar las extensiones y complementos que se crean para Visual Studio en un entorno diferente, y de esta forma no modificar el comportamiento de la instancia con la que estamos trabajando.

11. Utilizando la instancia experimental de pruebas de Visual Studio, crear un nuevo proyecto del tipo Class Library u otro que permita acceder a un editor de código.

12. Abrir el editor de código y será posible ver en el editor de código fuente, en la sección superior comienza a pasar automáticamente el video de Channel 9 con el fondo naranja que definimos en la clase C9VideoMargin, en la línea 31.

Figura 8.- Ejemplo en ejecución

2.2.- Tutorial: Trabajando con los nuevos tipos de selección

en el IDE

El siguiente tutorial demuestra un ejemplo sobre las posibilidades que posee los

tipos de selección en los editores de texto en Visual Studio 2010.



2. Crear un nuevo proyecto de tipo Class Library en C#.

3. Renombrar la clase [Class1.cs] por [BoxSelectionAndMultiEdit.cs]

4. Modificar el código de la clase [BoxSelectionAndMultiEdit] como demuestra el siguiente ejemplo:

class BoxSelectionAndMultiEdit

{

public readonly string Nombre;

public readonly string Apellido;

public readonly string EMail;

}

CheckPoint: Supongamos que se desea modificar todos los campos para que no

sean de solo lectura, es decir eliminar las sentencias readonly.

5. Posicionando el cursor del mouse sobre el primer readonly y presionando la tecla ALT, es posible seleccionar en modo Box todas las palabras readonly, como muestra la siguiente imagen.

Figura 9.- Selección en modo Box

6. Presionar la tecla [Delete] y esta acción eliminará el contenido de nuestra

selección.

7. El código fuente quedaría como en la siguiente imagen:

Figura 10.- Código editado

CheckPoint:Si por ejemplo, a todos los campos definidos se les desea agregar el

prefijo [cliente], es posible realizar esta acción con los siguientes pasos.


8. Posicionar el cursor del mouse al comienzo de la letra N de Nombre y seleccionar en forma descendente todas las líneas.

9. La selección es lo que se conoce como Zero Selection y debe queda como en la siguiente imagen.

Figura 11.- Selección en modo Zero Line

10. A continuación teclear la palabra cliente y la misma se agregará automáticamente como prefijo de los campos de la clase.

Figura 12.- Edición de texto multi línea

CheckPoint: Finalmente si necesitamos agregar un comentario común para los 3

campos, también podemos aprovechar las capacidades de BoxSelection y MultiEdit para realizar esta tarea.

11. Utilizando la capacidad de selección con la tecla ALT, seleccionar una columna 4 espacios después de la definición de los campos.

Figura 13.- Selección en modo Box


12. Con esta selección activa, teclear el comentario común para todos los campos. Esta acción habilita la opción de MultiEdit y crea el código común para todas las secciones como muestra la siguiente figura

Figura 14.- Inserción de comentarios multi línea

3.- LA NUEVA START PAGE Tengo que admitir que nunca fui muy amigo de la página de bienvenida de Visual

Studio (Start Page a partir de este momento). Por un lado, me gustaba la idea de tener un lector de RSS junto al listado de proyectos recientes; pero siempre prefería configurar Visual Studio para que se inicie con el IDE vacío y yo luego vería que hacer dentro. Esto lo hacía porque usualmente, el proyecto en el que trabajo no aparecía en la lista de los 6 proyectos que muestra la Start Page en Visual Studio 2008, y para ver contenidos RSS utilizo otras herramientas.

Figura 15.- Start Page en Visual Studio 2008


En Visual Studio 2010 la nueva Start Page incorpora una serie de funcionalidades que realmente hacen que la misma sea práctica y útil para ser utilizada. Lo primero que debemos agradecer es que si abrimos un proyecto desde la Start Page, una vez cargado un proyecto, la Start Page se cierra. Esto que parece algo trivial, es una acción que he visto automatizada en muchos desarrolladores en los últimos años: abrir un proyecto desde la Start Page y a continuación cerrar la Start Page para comenzar a trabajar.

Figura16.-Start Page en Visual Studio 2010

Como casi todo dentro de Visual Studio 2010, existe la posibilidad de configurar el

comportamiento de acuerdo al gusto del desarrollador, en este caso, esta opción se puede modificar directamente desde las opciones que posee la propia Start Page, junto con la opción de mostrar la Start Page al iniciar Visual Studio. La siguiente imagen muestra las opciones de configuración que se pueden modificar en la Start Page.

Figura 17.- Modificando el comportamiento de la Start Page


Otro detalle interesante, es que se ha organizado la misma para que en la sección superior izquierda tengamos a mano las opciones más corrientes como crear o abrir un proyecto, e inclusive se ha incorporado la opción para conectarse a un servidor Team Foundation Server. Asimismo en el listado de proyectos recientes, es posible eliminar elementos del listado, o dejar anclados elementos que utilicemos frecuentemente para que aparezcan dentro de la misma. La siguiente imagen muestra como aparece en la Start Page, la posibilidad de anclar el proyecto, eliminarlo de la lista, abrir el proyecto o abrir el directorio donde se encuentra el proyecto.

Figura 18.- Editando elementos en la Start Page

Finalmente la sección central de la Start Page, posee una serie de pestañas que

presentan una evolución al lector RSS de la Start Page de Visual Studio 2008, donde es posible encontrar accesos directos a tutoriales, novedades, etc.; organizados por categorías.

Y todo esto es posible ya que la Start Page es una página WPF; con lo que las posibilidades de adaptación y mejora son muy amplias. En otras palabras es posible modificar al gusto del desarrollador, el proyecto o una organización, el comportamiento y funcionalidades que se desean incluir en la misma en Visual Studio 2010.

3.1.- Tutorial: Personalizando la Start Page

El siguiente tutorial demuestra cómo realizar cambios sobre la Start Page en Visual

Studio 2010 y como desplegar estos cambios para que sean visibles en el IDE de Visual Studio. Para esto se utiliza un proyecto de ejemplo incluido en el perfil de cada usuario que tiene los componentes bases de la Start Page que utiliza Visual Studio 2010.


2. Abrir el proyecto de ejemplo de la Start Page que posee Visual Studio 2010. Por defecto está en la carpeta Mis Documentos de nuestro perfil de Windows, por ejemplo en [C:\Users\<user>\Documents\Visual Studio 10\StartPages].