Está en la página 1de 33

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
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.
 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.

vi
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

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

viii
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

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

x
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

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

xii
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

Novedades en el IDE

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.

1
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
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:
4 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

 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.
Novedades en el IDE 5

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 +.
6 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

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

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

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.
Novedades en el IDE 7

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
8 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

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
Novedades en el IDE 9

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);
10 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

// 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
Novedades en el IDE 11

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.
12 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

1. Abrir 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.
Novedades en el IDE 13

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
14 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

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
Novedades en el IDE 15

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
16 Visual Studio 2010 .NET 4.0 y ALM - Actualízate desde la versión 2008

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.

1. Abrir 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].