PRECIO: $ 2,795.00 PESOS MEXICANOS

$ 279.50 DOLARES

 

FICHA TECNICA:

  • PAGINAS: 320
  • AUTOR: Bruno Capuano (Team System/ALM MVP)
  • TOMOS: 1
  • CODIGO: KS102
  • IDIOMA: ESPAÑOL
  • FORMATO: TAPA BLANDA, 17.0x23.0 cm
  • EDICION: 1ª.
  • FECHA ED.: 2010

RESEÑA:

Siempre que aparece una nueva versión de Visual Studio, los programadores nos entusiasmamos con la misma ya que esperamos ver qué nuevas herramientas se han incorporado, y además descubrir mejoras en las que ya conocemos. Algunas Releases son una mejora de la versión anterior y nos suelen decepcionar, pero este no es el caso de Visual Studio 2010. Esta versión es una Major Release comparada con Visual Studio 2008, y posee cambios estructurales, como por ejemplo el nuevo entorno (IDE) basado en WPF; la inclusión de nuevas herramientas de modelado, y muchas novedades más que hacen que sentarse frente al IDE sea una experiencia completamente nueva.

Es por eso que en este libro se proporciona un completo recorrido por los cambios más importantes de la versión 2010. Además, en cada tema se han agregado una serie de tutoriales que permiten no solo leer sobre las nuevas herramientas, sino también poder probar las mismas en pocos minutos (ojo que algunos tutoriales ¡son un poco complicados!).  El contenido abarca temas que van desde como extender el nuevo IDE utilizando MEF, hasta como generar código a partir de un diagrama UML. También hay otros ejemplos más variados, por ejemplo: cómo trabajar con IntelliTrace, repasar las novedades que se incorporan en C++, C# y Visual Basic, dar un primer acercamiento inicial a F#, dar un repaso a las nuevas herramientas de modelado (UML Designers) y a las nuevas herramientas de arquitectura, conocer las opciones que tenemos para la gestión de proyectos con Team Foundation Server 2010, y muchas más.

Finalmente, se han agregado secciones especiales "del friki" en las que se dedica un poco de texto a temas de más bajo nivel o a curiosidades propias de Visual Studio o de .Net Framework 4.0.

.Net Framework 4.0 y Visual Studio 2010 suponen un cambio tan grande, que necesariamente se han tenido que dejar en el camino algunos temas amplios. No obstante este libro es un buen punto de partida para conocer Visual Studio 2010 y poder comenzar a trabajar en este nuevo entorno.

INDICE:

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

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

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

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

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

SOBRE EL AUTOR:

Bruno Capuano

Bruno Capuano
Team System/ALM MVP

Bruno es un experimentado y proactivo desarrollador y arquitecto de software con una probada trayectoria de contrucción de soluciones basadas en tecnología Microsoft.
Ha trabajado en roles del departamento de desarrollo, análisis de sistemas y gestión de proyectos de gran envergadura en diversos países. Ha actuado de ponente en varios eventos importantes de la industria.