Visual Studio

Visual Studio 2017
Sucintamente
Por Alessandro
Del Sole
Prólogo de Daniel Jebaraj
2
Copyright © 2017 por Syncfusion, Inc.
2501 Centro aérea Parkway
suite 200
Morrisville, NC 27560
Estados Unidos
Todos los derechos reservados.
yo mportante información de licencias. Por favor lee.
Este libro está disponible para su descarga gratuita desde www.syncfusion.com al término de un formulario de inscripción.
Si ha obtenido este libro de cualquier otra fuente, por favor registrarse y descargar una copia gratuita de
www.syncfusion.com .
Este libro tiene licencia para sólo lectura si se obtiene de www.syncfusion.com .
Este libro se licencia exclusivamente para uso personal o educativo.
Está prohibida la redistribución en cualquier forma.
Los autores y los titulares de derechos de autor proporcionan absolutamente ninguna garantía de ninguna información proporcionada.
Los autores y los titulares de derechos de autor no se hace responsable de cualquier reclamación, daños y perjuicios, o cualquier otra responsabilidad que pudiera derivarse
de, fuera de, o en relación con la información de este libro.
Por favor, no use este libro si los términos que se enumeran son inaceptables.
Uso constituirá la aceptación de los términos mencionados.
Syncfusion, de manera sucinta, ofreciendo innovación con facilidad, esencial y ESENCIALES .NET son la
marcas comerciales registradas de Syncfusion, Inc.
Crítico técnica: James McCaffrey
Editor de copia: John Elderkin
Coordinador de adquisiciones: Tres Watkins, gerente de desarrollo de contenidos, Syncfusion, Inc.
Corrector de pruebas: Graham alta, productor de contenidos de alto nivel, Syncfusion, Inc.
3
Tabla de contenido
La historia detrás de la serie de libros Sucintamente .......................................... ......................................... 8
Sobre el Autor ............................................... .................................................. ...................................... 10
Introducción ................................................. .................................................. ............................................ 11
Capítulo 1 Una nueva experiencia de instalación ............................................ .................................................. 12
La solución de la complejidad de la instalación de Visual Studio .......................................... ............................... 12
Instalar Visual Studio 2017 .............................................. .................................................. .................. 12
Personalización de la instalación con componentes individuales ............................................ ........................... 15
Instalación de varias ediciones ............................................... .................................................. ..................... 17
Modificación de la instalación de Visual Studio 2017 ............................................ ............................................ 17
El lanzamiento de Visual Studio 2017 .............................................. .................................................. ............... 17
Resumen del capítulo ................................................ .................................................. ................................ 17
Capítulo 2 La página de inicio Revisited ............................................ .................................................. ......... 18
experiencia de arranque optimizado ............................................... .................................................. ................... 18
Mantenerse al día: Anuncios y noticias .......................................... ........................................... 19
Atajos para soluciones, proyectos y carpetas .......................................... ............................................... 20
Trabajar con proyectos utilizados más recientemente ............................................ ............................................... 20
Acceder a las plantillas de proyecto ............................................... .................................................. ............... 21
Abrir proyectos, carpetas y repositorios de control de código fuente ........................................ ................. 21
Capítulo 3 Código Editor Mejoras ............................................. .................................................. .... 22
mejoras de IntelliSense ................................................ .................................................. ................... 22
Código de navegación más fácil .............................................. .................................................. ................ 23
Encuentra todas las referencias ............................................... .................................................. ............................. 24
Navegando código con Ir a ............................................. .................................................. .................. 26
4
líneas de guía Estructura ............................................... .................................................. ........................... 27
análisis de código Roslyn ............................................... .................................................. ............................ 28
Más refactorizaciones Roslyn ............................................... .................................................. .................... 28
El control de análisis en vivo con estilo de código ............................................ .................................................. 32
mejoras de edición para C ++ y F # ............................................ .................................................. ..... 47
Capítulo 4 Mejoras XAML .............................................. .................................................. .............. 48
XAML Editar y continuar .............................................. .................................................. ........................ 48
XAML mejoras editor de código .............................................. .................................................. ........... 49
Navegando código con Ir a ............................................. .................................................. .................. 50
IntelliSense filtrado ................................................ .................................................. ............................ 50
espacios de nombres de refactorización ................................................ .................................................. ................... 50
XAML Diagnóstico ................................................ .................................................. ................................ 53
Capítulo 5 Trabajar con las soluciones, carpetas y Idiomas ........................................ ...................... 56
Ligera carga Solución ............................................... .................................................. ..................... 56
soporte de lenguaje extendido ............................................... .................................................. .................. 57
Abrir carpeta: El uso de cualquier código base ........................................... .................................................. 58
La creación de la demo .............................................. .................................................. ............................. 58
soporte de lenguaje Basic en Visual Studio 2017 ........................................... ......................................... 59
Amplia compatibilidad con el idioma a través de las cargas de trabajo y herramientas ........................................... ....................... 61
¿Qué hay de nuevo para los proyectos de control de la fuente y del equipo .......................................... ........................................ 71
Capítulo 6 Extensiones y extensibilidad ............................................. .................................................. 75 ..
Qué hay de nuevo con extensiones en Visual Studio 2017 .......................................... ...................................... 75
Itinerancia Administrador de extensiones ............................................... .................................................. ............. 75
La programación de las operaciones sobre las extensiones de .............................................. ................................................. 76
5
Qué hay de nuevo con la extensibilidad .............................................. .................................................. ................. 78
Crear una extensión en blanco para fines de demostración ........................................... ........................................ 78
Especificación de requisitos previos de extensión ............................................... .................................................. ..... 79
el apoyo y el archivo de instalación personalizada NGEN ............................................ ................................................ 81
Capítulo 7 depuración y pruebas Mejoras ............................................ .................................... 83
La introducción de ejecución para hacer clic .............................................. .................................................. ......................... 83
ventanas de diagnóstico actualizados ............................................... .................................................. ................ 84
Análisis de excepciones con el ayudante de excepción ............................................ ....................................... 86
Al presentar en vivo de pruebas unitarias .............................................. .................................................. ................. 88
mejoras Varios ................................................ .................................................. .............. 92
Mejoras de accesibilidad ................................................ .................................................. ................ 93
IntelliTrace eventos para .NET Core ............................................ .................................................. .......... 93
Perfilado actualizaciones herramientas ............................................... .................................................. ........................ 93
Soporte para Chrome con JavaScript ............................................. .................................................. ..... 93
Capítulo 8 Visual Studio 2017 para el desarrollo móvil .......................................... .............................. 94
Visual Studio 2017 y la plataforma Windows universal .......................................... ............................ 94
Actualizaciones para .NET nativo ............................................. .................................................. ........................ 95
NuGet paquetes actualizados ............................................... .................................................. .................. 96
mejoras XAML para UWP .............................................. .................................................. ............. 96
Actualizado Diseñador Manifiesto ............................................... .................................................. ................ 97
Herramienta de análisis de la interfaz de usuario ............................................... .................................................. ................................. 100
desarrollo multiplataforma con Apache Cordova ........................................... ................................. 102
versiones y plataformas compatibles .............................................. .................................................. ..... 103
En el navegador de simulación con Córdoba Simular ........................................... ........................................ 103
coloración mensaje ................................................ .................................................. ....................... 105
6
En subproducto adquisición de herramientas de desarrollo ........................................... ........................................... 105
desarrollo multiplataforma con Xamarin ............................................ .............................................. 106
corrección automática de dependencias que faltan Android ............................................ ................................... 106
Cambios a las plantillas de proyecto .............................................. .................................................. ............. 107
editor de .Plist unificado para iOS ............................................ .................................................. ................... 109
Resumen del capítulo ................................................ .................................................. .............................. 111
Capítulo 9 Visual Studio 2017 por Cloud y Desarrollo Web ........................................ ............... 112
La creación de aplicaciones multiplataforma con .NET 1.1 Core ........................................ ........................................ 112
La introducción de herramientas para contenedores de Docker ............................................. .................................................. 117
Configuración del entorno de desarrollo ............................................. ............................................. 117
Activación del estibador en proyectos .NET ............................................ .................................................. ....... 119
Ejecución de un contenedor de estibador en Azure ............................................ .................................................. . 120
La introducción de capacidades de servicio ............................................... .................................................. ......... 125
aplicaciones Node.js construcción ............................................. .................................................. ................ 129
herramientas actualizadas para Microsoft Azure ............................................. .................................................. ........ 133
actualizaciones nube Explorador ............................................... .................................................. .................... 134
Resumen del capítulo ................................................ .................................................. .............................. 136
7
La historia detrás de la Sucintamente Serie
de libros
Daniel Jebaraj, vicepresidente
Syncfusion, Inc.
S
Taying en el borde de corte
Como muchos de ustedes saben, Syncfusion es un proveedor de componentes de software para la plataforma
Microsoft. Esto nos pone en la posición apasionante pero difícil de estar siempre a la vanguardia.
Siempre que las plataformas o herramientas están enviando fuera de Microsoft, que parece estar a punto cada dos semanas
en estos días, tenemos que educarnos, de forma rápida.
La información es abundante, pero más difícil de digerir
En realidad, esto se traduce en una gran cantidad de pedidos de libros, búsquedas de blogs, Twitter y las exploraciones.
Mientras más información se está convirtiendo disponible en Internet y cada vez más se están publicando libros, incluso en temas
que son relativamente nuevos, un aspecto que nos sigue es inhibir la imposibilidad de encontrar tecnología concisa los libros de
resumen.
Nos enfrentamos por lo general con dos opciones: leer varios libros de 500 páginas, o buscar en la web para las entradas del blog pertinentes y otros
artículos. Al igual que todos los demás que tiene un trabajo que hacer y servir a los clientes, nos encontramos con esta bastante frustrante.
los Sucintamente serie
Esta frustración se tradujo en un profundo deseo de producir una serie de libros técnicos concisos que se dirigirían a los
desarrolladores que trabajan en la plataforma Microsoft.
Creemos firmemente, teniendo en cuenta los conocimientos básicos tales desarrolladores tienen, que la mayoría de los temas se pueden
traducir en libros que son entre 50 y 100 páginas.
Esto es exactamente lo que nos dispusimos a lograr con el Sucintamente serie. No es todo lo maravilloso nace de un
profundo deseo de cambiar las cosas para mejor?
Los mejores autores, los mejores contenidos
Cada autor se ha escogido de un grupo de expertos con talento que comparten nuestra visión. El libro que tiene en sus manos, y los otros
disponibles en esta serie, son el resultado del trabajo incansable de los autores. Va a encontrar el contenido original que está garantizado
para que pueda ponerse en funcionamiento en aproximadamente el tiempo que se tarda en tomar unas tazas de café.
8
Siempre libre
Syncfusion va a trabajar para producir libros sobre varios temas. Los libros siempre serán libres. Cualquier actualización que publicamos
también serán libres.
¿Gratis? ¿Cuál es la trampa?

No hay truco aquí. Syncfusion tiene un interés personal en este esfuerzo.
Como proveedor de componentes, nuestra pretensión única siempre ha sido que ofrecemos marcos más amplios y profundos que cualquier otro en
el mercado. Formación de desarrolladores en gran medida nos ayuda a comercializar y vender en contra de proveedores de la competencia que
prometen “habilitar el soporte de AJAX con un solo clic,” o “pasar la luna de queso!”
Háganos saber lo que piensas

Si usted tiene cualquiera de los temas de interés, pensamientos o comentarios, por favor enviarlos a nosotros en
succinctly-series@syncfusion.com .
Esperamos sinceramente que disfrute de este libro y que le ayuda a comprender mejor el tema de estudio. Gracias por
leer.
Por favor, siga con nosotros en Twitter y “Me gusta” en Facebook para ayudar a difundir la
palabra sobre el Sucintamente ¡serie!
9
Sobre el Autor
Alessandro Del Sole ha sido un Microsoft Most Valuable Professional (MVP) desde 2008. Otorgado MVP del Año en 2009,
2010, 2011, 2012, y 2014, es reconocido internacionalmente como un experto en Visual Studio y una autoridad de Visual Basic
y .NET . Alessandro autor de numerosos libros y libros electrónicos sobre la programación con Visual Studio, que incluye Visual
Studio Código Sucintamente , Visual Basic 2015 Unleashed, Roslyn Sucintamente y Visual Basic 2012 liberado.
Ha escrito numerosos artículos técnicos sobre .NET, Visual Studio y otras tecnologías de Microsoft en italiano y en Inglés
para muchos portales de desarrollo, incluyendo MSDN Magazine y el Centro de desarrolladores de Visual Basic de Microsoft.
Es un orador frecuente en conferencias italianos, y él ha dado a conocer una serie de aplicaciones de Windows Store.
También ha producido una serie de videos de instrucción, tanto en Inglés e italiano. Alessandro funciona como mayor
desarrollador .NET, formador y consultor. Lo puedes seguir en Twitter en @progalex .
10
Introducción
“Cualquier desarrollador, cualquier plataforma, cualquier dispositivo.” Si usted asistió (en persona o en línea) una conferencia reciente
de Microsoft, como // Construir 2016, Ignite, o en Conectar (); 2016, estas palabras no sonarán nueva. Representan la visión y la
ambición detrás del lanzamiento de Microsoft Visual Studio 2017 como herramienta de desarrollo de última apoyar las estrategias
más recientes de Microsoft. Hasta hace unos años, Microsoft Visual Studio es el entorno de desarrollo de elección si usted quiere
construir aplicaciones web de Windows y basado en .NET Framework con C #, C #, Visual Basic y C ++. Si quería (o necesario) para
crear aplicaciones para diferentes sistemas operativos, plataformas o dispositivos distintos a un PC, se tenía que utilizar las
herramientas de desarrollo de propiedad y marcos nativos en plataformas específicas.
En los últimos años, Microsoft ha cambiado significativamente su estrategia, la apertura a otras plataformas, que abarca de código
abierto, y se centra aún más en servicios en la nube. De hecho, la compañía ha estado realizando importantes inversiones para traer
tecnologías, plataformas, herramientas de desarrollo, marcos y servicios a otros sistemas operativos como Linux y Mac OS, y que por
lo general el público no es de Microsoft (ya veces hostil), centrándose en los servicios mucho más que en el pasado. En esta
estrategia, .NET Core, la fuente abierta modular, tiempo de ejecución multiplataforma, permite a los desarrolladores de C # para
escribir aplicaciones que se ejecutan en Windows, Linux y Mac. Con Xamarin, puede escribir aplicaciones móviles que funcionan con
Android, iOS y Windows con una sola, C # código base compartida. SQL Server 2016 tiene ahora una vista previa que se ejecuta en
Linux, un hito revolucionario para Microsoft. Una vista previa de Visual Studio para Mac está disponible actualmente, y permite
totalmente desarrolladores de C # para escribir aplicaciones multiplataforma con .NET Core y Xamarin en Mac OS. En este
multiplataforma y multidispositivo visión, la nube es aún más importante. De hecho, Azure alberga todos los servicios nuevos y
existentes Microsoft está ofreciendo, y crece de acuerdo a lo que demanda el mercado, por ejemplo, contenedores de alojamiento
acoplables en Linux.
Siendo el principal entorno de desarrollo de Microsoft, Visual Studio 2017 encaja perfectamente en este primer móvil,
mundo en la nube en primer lugar; los desarrolladores pueden utilizar Visual Studio 2017 para crear aplicaciones que
se ejecutan en cualquier plataforma y dispositivo con el idioma y el marco de su elección. Por ejemplo, Visual Studio
2017 permite escribir aplicaciones Node.js, iOS nativas y aplicaciones para Android, y aplicaciones web que se
ejecutan en Linux y Mac OS. La buena noticia es que, como el desarrollador, puede seguir utilizando las mismas
herramientas poderosas que ya conoce, como el depurador, IntelliSense, y perfiladores contra todas las plataformas de
desarrollo compatibles. En este libro electrónico,
Al igual que con sus predecesores, Visual Studio 2017 está disponible en diferentes ediciones, como la Comunidad, Professional y
Enterprise. Si una función requiere una edición específica, se puso de relieve cuando sea apropiado. Usted puede descargar la
edición de la comunidad de forma gratuita.
Un descargo de responsabilidad-este e-libro final ha sido escrito basado en la versión Release Candidate (RC) de Visual Studio 2017, lo que significa
que algunas herramientas pueden estar sujetos a cambios leves en la versión final.
Este libro está dedicado a mi novia Angélica. Estoy muy agradecido por todo lo que hacen por nosotros.
Alessandro
11
Capítulo 1 Una nueva experiencia de instalación
Microsoft Visual Studio ha sido siempre un entorno de desarrollo muy potente. Una de las razones de su poder es que se
puede ver en varias plataformas de desarrollo y, con las versiones 2013 y 2015, incluso se añadió la opción de orientar las
tecnologías no son de Microsoft y sistemas operativos. Por ejemplo, pensar en Android y iOS desarrollo tanto con Xamarin
y Apache Cordova. Pero gran poder también significa una infraestructura compleja, y en el pasado Visual Studio requiere
muchas horas para la instalación y una gran cantidad de espacio en disco. En Visual Studio 2017, Microsoft ofrece una
nueva experiencia de instalación que simplifica el proceso y ahorrar tiempo y espacio en disco. Instalar Visual Studio 2017
será su primera experiencia con la nueva versión, y merece una discusión a fondo.
La solución de la complejidad de la instalación de Visual Studio
Teniendo en cuenta la importancia de los resultados globales y la eficiencia de su herramienta de desarrollo de estreno, uno de los
objetivos de Microsoft para Visual Studio 2017 era simplificar el proceso de instalación para salvar a los desarrolladores de tiempo y
espacio en disco. Con Visual Studio 2015, una instalación completa requiere muchos gigabytes de disco y varias horas en completarse.
La solución de este problema significa repensar toda la infraestructura IDE y cambiar tanto la forma en Visual Studio consume los
componentes y que se basa en la forma en que permite dirigidos a diferentes plataformas de desarrollo. Sobre la base de estos
cambios, Visual Studio 2017 ahora se hace de una concha de núcleo que incluye el editor de código y herramientas esenciales, referido
como editor de Visual Studio núcleo. Esto proporciona la capacidad para escribir código en varios idiomas, incluyendo (pero no
limitados a) Visual Basic, C #, C ++ y Python, junto con la coloración de sintaxis, IntelliSense, y el apoyo de depuración, todo ello en el
entorno familiar de Visual Studio (ver Capítulo 5, "Utilización de soluciones, carpetas, y los idiomas" ).
Además, Visual Studio 2017 admite la adición de conjuntos de componentes, cada uno para un escenario de desarrollo específico. Cada
conjunto de componentes que se conoce como una carga de trabajo. Las cargas de trabajo hacen que la instalación y el mantenimiento más
fácil y permite a los desarrolladores para instalar lo que realmente necesitan, sin componentes innecesarios, SDK y herramientas. Incluso se
puede decidir instalar sólo el editor de Visual Studio núcleo sin ningún tipo de cargas de trabajo adicionales con el fin de obtener el entorno de
codificación básica, lo que reduciría el espacio necesario para la instalación de Visual Studio para alrededor de 750 megabytes. Es probable
que tenga algo más que el resaltado de sintaxis, lo que significa que tendrá que seleccionar las cargas de trabajo de esta adecuadas sólo te
da una idea de cómo la infraestructura de Visual Studio ha sido revisada. La siguiente sección describe cómo instalar Visual Studio 2017 y
explicar más acerca de las cargas de trabajo y lo que puede hacer con cada uno.
Instalar Visual Studio 2017
Consejo: Visual Studio 2017 se puede instalar lado a lado en una máquina que tiene las versiones anteriores del IDE
instalado.
12
Al iniciar el programa de instalación, se le pedirá con una completamente nueva interfaz de usuario que presenta una lista de las cargas de
trabajo. Esto se representa en la Figura 1.
Figura 1: Inicio de la instalación de Visual Studio 2017
Como se puede ver, las cargas de trabajo se agrupan por las siguientes categorías:
• ventanas
• Web y la nube
• Móviles y juegos
• otros conjuntos de herramientas
Todas las cargas de trabajo disponibles pueden ser descubiertos por desplazamiento a través de la lista (ver Figura 2).
Figura 2: Las cargas de trabajo adicionales
13
Se pueden seleccionar todas las cargas de trabajo que necesita para su trabajo diario con Visual Studio 2017. Si no selecciona ningún cargas de
trabajo, sólo se instalará el editor principal de Visual Studio. En el lado derecho del cuadro de diálogo, puede expandir el nombre de la carga de
trabajo y ver qué componentes se incluye y una lista de componentes adicionales, individuales. La Tabla 1 muestra las cargas de trabajo
disponibles en más detalle.
Tabla 1: Las cargas de trabajo disponibles para Visual Studio 2017
Nombre Descripción
Desarrollo de plataformas de Seleccione esta carga de trabajo si se desea escribir aplicaciones universales para Windows 10,
Windows universal incluyendo PC, tabletas, teléfonos inteligentes, dispositivos HoloLens, Xbox, y la IO.
. desarrollo de Seleccione esta carga de trabajo si se desea construir aplicaciones clásicas de escritorio de Windows
escritorio NET con las formas de WPF, Windows y aplicaciones de consola utilizando el .NET Framework. Esto
proporciona un menor tiempo de carga de solución y mejora de IntelliSense, navegación de código y
refactorizaciones. Incluye nuevas características tales como XAML Editar y continuar y correr a Haga
clic en la depuración, los cuales se discuten en este libro electrónico.
desarrollo de escritorio con C Seleccione esta carga de trabajo si se desea crear, construir y depuración nativa, las aplicaciones
++ clásicas de ordenador que se ejecutan en versiones que van desde Windows XP a la última versión
de Windows 10, utilizando el lenguaje C ++ y el medio ambiente.
ASP.NET y desarrollo Seleccione esta carga de trabajo para desarrollar aplicaciones web usando tecnologías basadas en
web estándares ASP.NET y como HTML, JavaScript, CSS, y JSON. Al igual que con escritorio .NET, esta
carga de trabajo incluye más corto tiempo de solución de carga, la mejora de IntelliSense,
navegación de código, refactorización y más, y se le permite desplegar rápidamente su aplicación a
un servidor web o en Azure.
desarrollo de Azure Esta carga de trabajo instala el último SDK Azure para .NET y herramientas para Visual Studio
2017. Se le permite ver los recursos en la nube Explorer, crear recursos utilizando herramientas
del Administrador de recursos Azure, y construir aplicaciones y servicios listos para ser alojado
en Azure.
desarrollo Node.js Esta carga de trabajo se suma todo lo necesario para construir aplicaciones para Node.js, incluyendo
IntelliSense, la depuración local y remota, perfilado, la integración NPM, una ventana interactiva, los
corredores de la prueba, y la integración Azure.
almacenamiento y Esta carga de trabajo proporciona herramientas para acceder a bases de datos en las instalaciones de SQL
procesamiento de datos Server, así como bases de datos SQL Azure y sobre los recursos Azure Lagos de datos. También proporciona
soporte para T-SQL, Colmena, y grandes volúmenes de datos en Azure.
Oficina / desarrollo de Esta carga de trabajo proporciona las herramientas para desarrolladores de Office, que permiten la creación
SharePoint de Office y SharePoint complementos y soluciones.
14
Nombre Descripción
.desarrollo multiplataforma Esta carga de trabajo instala todas las herramientas que necesita para escribir aplicaciones web
.NET Core multiplataforma con .NET Core, con soporte para el despliegue de contenedores acoplables.
desarrollo móvil con .NET Esta carga de trabajo instala Xamarin, la tecnología que permite crear iOS nativas, Android y la
plataforma de Windows universal aplicaciones usando una base de código C # compartido.
El desarrollo del juego con Seleccione esta carga de trabajo si se quiere desarrollar 2D multiplataforma y juegos en 3D utilizando
Unity el marco de la Unidad y herramientas integradas para Visual Studio 2017.
desarrollo móvil con Esta carga de trabajo instala Apache Cordova para la creación de aplicaciones móviles
JavaScript multiplataforma utilizando HTML y JavaScript dentro de Visual Studio.
desarrollo móvil con C ++ Seleccione esta carga de trabajo si se desea crear aplicaciones móviles multiplataforma usando C
++.
El desarrollo del juego con Seleccione esta carga de trabajo si se desea crear juegos usando C ++.
C ++
desarrollo de extensiones de Esta carga de trabajo instala el SDK de Visual Studio y le permite escribir extensiones como
Visual Studio nuevos comandos, ventanas de herramientas y plantillas.
el desarrollo de Linux con C ++ Esta carga de trabajo le permite al autor de código C ++ para servidores Linux, ordenadores de
sobremesa y dispositivos dentro de Visual Studio 2017.
Para los propósitos de instrucción de este e-libro, he instalado todas las cargas de trabajo disponibles. Usted no está obligado a hacer lo mismo,
sensación libre de seleccionar sólo los que necesita. Más tarde, puede instalar las cargas de trabajo adicionales según sea necesario.
Personalización de la instalación con componentes individuales
A pesar de que las cargas de trabajo ayudan a mantener la simplicidad de instalación, es posible que aún tenga que instalar componentes individuales. En la
Figura 2, se verá un artículo llamado Componentes individuales. Haga clic en él para acceder a la lista completa de los componentes individuales que se
pueden instalar sin tener en cuenta las cargas de trabajo seleccionadas (ver Figura 3).
15
Figura 3: Selección de componentes individuales
A modo de ejemplo, la extensión de GitHub para Visual Studio 2017 no está seleccionada de forma predeterminada, lo que significa que
es posible que desee seleccionar este componente si va a trabajar con repositorios Git en ese popular servicio. Una vez que haya hecho
su selección, haga clic Cerca y seleccione la edición de Visual Studio 2017 que desea instalar. Un diálogo mostrará el progreso de la
operación (véase la figura 4).
Figura 4: Progreso de la instalación
El tiempo necesario para la instalación completa depende del número de cargas de trabajo y de su conexión a Internet. Pero incluso con
muchas cargas de trabajo seleccionadas, se dará cuenta de que va mucho más rápido que las instalaciones anteriores de Visual Studio.
dieciséis
Instalación de varias ediciones
Con Visual Studio 2017, que finalmente puede instalar varias ediciones en la misma máquina. Esta gran característica significa que usted
puede instalar las ediciones Comunidad, profesionales y empresas en la misma máquina (o cualesquiera dos de ellos). Ahora esto es posible
debido a que cada edición se instala en una subcarpeta específica en el sistema. Además de ejecutar los instaladores independientes, se
podría poner en marcha una nueva instalación directamente desde el programa de configuración actual. La figura 4 muestra un botón de
instalación, tanto para la Comunidad y Professional, mientras que la empresa se va a instalar.
Nota: Los conjuntos de núcleo de Visual Studio ya no se instalan en la caché de ensamblados global (GAC). Con el
fin de apoyar la instalación de múltiples ediciones, la mayoría de los montajes requeridos por Visual Studio 2017
ahora residen en C: \ Archivos de programa (x86) \ Microsoft Visual
Studio \ 2017 \% EditionName% \ Common7 \ IDE \ PublicAssemblies, donde% EditionName% es la

edición instalada (como comunitario, profesional, o Enterprise).
Modificación de la instalación de Visual Studio 2017
Visual Studio 2017 ofrece un nuevo acceso directo para modificar una instalación existente. Sólo tiene que ir a la Windows> Todos los
programas menú y seleccionar la Instalador de Visual Studio atajo. Esto iniciará el programa de instalación, y usted tendrá la opción de
agregar o eliminar las cargas de trabajo o componentes individuales.
El lanzamiento de Visual Studio 2017
Al igual que su predecesor, Visual Studio 2017 lanzamientos utilizando el mismo nombre de acceso directo en el menú Todos los programas.
Cuando se inicia por primera vez, Visual Studio le pedirá sus credenciales de cuenta de Microsoft para conectarse (opcional). Como se puede
saber, entrar en una cuenta de Microsoft permitirá que para la sincronización de configuración a través de máquinas. Esto también restablecerá
automáticamente la configuración personalizada que pueda tener en una instalación existente VS 2017. Al poner en marcha Visual Studio, se le
reconocerá inmediatamente un mejor rendimiento y puesta en marcha más rápido que Visual Studio
2015. Otras novedades de inicio se describen en el siguiente capítulo.
Resumen del capítulo
Visual Studio 2017 introduce una nueva experiencia de instalación basado en el editor de Visual Studio central y una serie de cargas de
trabajo, cada uno de los escenarios de desarrollo de orientación específicos. Esto no sólo simplifica el proceso de configuración, pero la
instalación de Visual Studio ahora es mucho más rápido y más eficiente. Todavía se mantiene el control total de los componentes
instalados, e incluso se puede instalar varias ediciones de Visual Studio 2017 en la misma máquina. Ahora que ha configurado el
entorno, encontrará algunas nuevas características en el lanzamiento de Visual Studio 2017 por primera vez.
17
Capítulo 2 La página de inicio Revisited
Visual Studio 2017 ha mejorado el rendimiento y la eficiencia de muchas maneras. Se dará cuenta de esto al
iniciar el IDE, que cargará más rápido que sus predecesores. No se limita a rendimiento, la nueva versión
ofrece una experiencia mejorada a través de un inicio de inicio Página revisada.
experiencia de arranque optimizado
los Página de inicio es el primer contacto que tendrá con Visual Studio 2017, lo que significa que juega un papel importante. En la
nueva versión, la página de inicio se ha reorganizado y optimizado para ofrecer más espacio para los atajos y herramientas comunes.
La figura 5 muestra la nueva página de inicio.
Figura 5: La nueva página de inicio
La primera característica nueva de la página de inicio permite al Comienza área a ser retirado haciendo clic en el x icono en la esquina
superior derecha. Esta área contiene accesos directos a recursos de aprendizaje y documentación, pero también se puede ocultar para
ahorrar espacio para otros contenidos. Estos se describen en las siguientes secciones.
18
Consejo: En Visual Studio 2017, el comando de menú para abrir la página de inicio se ha movido de la Ver menú
para el Archivo menú.
Mantenerse al día: Anuncios y noticias
Al igual que con sus predecesores, Visual Studio 2017 ofrece una lista de anuncios y noticias de los canales oficiales de Microsoft (ver
Figura 5). Sin embargo, en la nueva versión, esta lista ha sido trasladado a un panel desplegable en la parte derecha de la página llamada Noticias
para desarrolladores. La figura 6 muestra cómo aparece la página de inicio con el panel desarrollador Noticias oculto.
Figura 6: El colapso de la Panel News desarrollador
Por el colapso del desarrollador panel de noticias, usted puede tener más espacio para artículos y herramientas utilizadas recientemente. Basta con hacer
clic en la flecha para restaurar el panel. Sin embargo, tenga en cuenta que cuando se derrumbó, se le notificará de noticias actualizadas a través de un
glifo naranja que recubrirá la flecha.
19
Atajos para soluciones, proyectos y carpetas
Visual Studio 2017 ofrece accesos directos para abrir y crear proyectos rápidamente. Esto no es nuevo, de hecho, pero hay
varios cambios y mejoras en la nueva versión.
Trabajar con proyectos usados más recientemente
La lista de proyectos usados más recientemente (MRU) está en el lado izquierdo de la página de inicio. Junto con los proyectos usados
recientemente, Visual Studio 2017 también mostrará la lista de repositorios que ha clonado recientemente de Servicios Studio Team
visuales y GitHub, que se representan con un icono de la carpeta. Aún más interesante, esta lista se sincroniza a través de máquinas si se
inicia sesión en Visual Studio con una cuenta de Microsoft, lo que significa que se pueden ver esta lista en cualquiera de sus instalaciones
de Visual Studio 2017. Esto hará que sea más fácil para clonar los mismos repositorios de todas sus máquinas. La figura 7 muestra la lista
de MRU, incluyendo repositorios clonados.
Figura 7: Lista de MRU y se clonó Repositories
20
Acceder a las plantillas de proyecto
La nueva página de inicio hace que sea más fácil para crear nuevos proyectos mediante la selección de diferentes plantillas. En el Nuevo
proyecto zona, que se puede ver en todas las figuras anteriores, se puede encontrar una lista de plantillas de proyectos usados recientemente
que puede hacer clic para crear un nuevo proyecto basado en esa plantilla. Esta lista se sincroniza a través de las máquinas, y también muestra
el lenguaje de programación utilizado con la plantilla de proyecto. De hecho, al hacer clic en una plantilla reciente, Visual Studio 2017 muestra el Nuevo
proyecto diálogo con la plantilla especificada ya seleccionada. También, haciendo clic Más plantillas de proyecto, el cuadro de diálogo Nuevo
proyecto aparecerá y proporcionar una opción para decidir qué plantilla de proyecto para su uso. Por último, puede buscar plantillas de proyecto
directamente en la página de inicio escribiendo en el Buscar plantillas de proyecto caja de texto.
Abrir proyectos, carpetas y repositorios de control de código fuente
los Abierto área en la página de inicio proporciona accesos directos para abrir proyectos y sitios web. Hay varias nuevas características muy
interesantes en Visual Studio 2017. La primera característica viene con un acceso directo llamado Carpeta abierta. Esto le permite abrir las
carpetas que contienen los surtidos sueltos de archivos de código que no se basan en sistemas de proyectos de propiedad. Esto será
examinado a fondo en
Capítulo 5, "Utilización de soluciones, carpetas y lenguas."
La segunda novedad hace que sea más fácil de abrir proyectos de los motores de control de fuentes tales como Team Foundation
Server, Visual Studio Team Servicios y Git. Como se puede ver en la figura 7, el grupo llamado Pedido de ofrece dos accesos
directos:
• Servicios de Visual Studio Team

• GitHub
El primer acceso directo le permitirá abrir proyectos de equipo o repositorios Git de ambos servicios Studio Team visuales y Team
Foundation Server. El segundo acceso directo le permite abrir o clonar repositorios Git desde GitHub. Por supuesto, todavía se pueden
administrar las conexiones del proyecto del equipo con la ventana de herramientas Team Explorer.
Sugerencia: El comando GitHub sólo está disponible si se instala la extensión de GitHub para Visual Studio 2017.
Este puede ser seleccionado fácilmente de la lista de componentes individuales dentro del instalador de Visual
Studio.
Visual Studio 2017 mejora la productividad de los desarrolladores desde el momento en que se inicia. Con la nueva página de inicio, el
espacio disponible se ha reorganizado con el fin de ofrecer más accesos directos a herramientas de uso común. Además, se han introducido
nuevas características para apoyar proyectos de equipo y repositorios, incluyendo la lista de repositorios recientemente clonado (que se
sincronizan a través de máquinas), y la opción de abrir proyectos de los motores de control de fuentes tales como Git y Servicios Visual Studio
Team.
21
Capítulo 3 Código Editor Mejoras
El editor de código es el lugar donde pasan la mayor parte de su vida del revelador, y Microsoft introduce mejoras en la
productividad en cada versión principal del IDE. Visual Studio 2017 no es una excepción, que introduce una serie de excelentes
características para mejorar su experiencia de codificación.
Nota: Todos los temas descritos en este capítulo se aplican a C # y Visual Basic, salvo que se especifique
expresamente. Además, recuerde que C #, Visual Basic, C ++ y C # también proporcionan una serie de nuevas
características del lenguaje que no están cubiertos en este capítulo, que en su lugar se centra en la experiencia de
edición de código. Visita el documentación de Visual Studio Para más información sobre las novedades de los
lenguajes de programación en Visual Studio 2017.
mejoras de IntelliSense
La herramienta IntelliSense ha sido durante mucho tiempo un mejor amigo de todos los desarrolladores utilizando Microsoft Visual Studio. En Visual Studio
2017, IntelliSense consigue importantes mejoras que le ayudarán a ahorrar tiempo mientras que la codificación. En primer lugar, IntelliSense es ahora más
inteligente con el filtrado. En lugar de sugerir el elemento superior de la lista, se muestra automáticamente el mejor resultado de la casación en base a lo que
ha escrito. Y, no se limita a esto, se inicia destacando las palabras en negrita a medida que escribe, como se muestra en la Figura 8.
Figura 8: Sugerencias IntelliSense y filtros
22
Filtrado basado en tipos o miembros específicos es otra mejora importante en Visual Studio. Como se puede ver en la Figura 8, hay una
nueva barra con muchos iconos en la parte inferior de IntelliSense, cada icono que representa un tipo particular de objeto o elemento tal
como variables locales, constantes, propiedades, campos, métodos, interfaces, clases, valor tipos, enumeraciones, delegados, espacios
de nombres, palabras reservadas, e incluso fragmentos de código. Por ejemplo, la Figura 9 muestra cómo restringir los miembros
búsquedas de IntelliSense a los métodos, clases, y fragmentos de código.
Figura 9: La búsqueda Filtrado IntelliSense
Haga clic en un icono para agregar o quitar el filtro especificado. Esta nueva opción simplifica radicalmente la forma en que puede aprovechar la
terminación de palabras, sobre todo cuando se sabe de antemano qué tipo de objetos que necesita para trabajar con ellos.
Código de navegación más fácil
Cambiar rápidamente de definiciones de tipos y las invocaciones miembros o tareas es crucial para la productividad,
especialmente con docenas de archivos de código. Visual Studio 2017 introduce una serie de mejoras interesantes para la
navegación de código, mejorando así su productividad.
23
Encuentra todas las referencias
Encuentra todas las referencias es una ventana popular herramienta que puede utilizar para ver dónde y cómo un objeto o miembro ha sido
utilizado a través de su solución. Todavía es más útil para los desarrolladores que no pueden tomar ventaja de las herramientas CodeLens,
que sólo está disponible en la edición Enterprise. Con versiones anteriores de Visual Studio, encontrar todos Referencias mostraron una
lista de líneas de código donde se utilizó un objeto o miembro, incluyendo su definición, y presentó una opción de doble clic en una línea en
la lista y ser redirigidos inmediatamente a la línea de código en el editor. En Visual Studio 2017, Encuentra todas las referencias grupos de
objetos y referencias miembros por proyecto y luego por tipo, con la coloración de sintaxis y una interfaz de usuario más intuitiva. La Figura
10 muestra un ejemplo basado en referencias a una clase llamada Persona, que se utiliza en dos proyectos diferentes.
Figura 10: Encontrar todas las referencias Grupos Referencias con la sintaxis Colorization
Como se puede ver, la nueva vista hace que sea más fácil de ver dónde y cómo un objeto se ha utilizado. La ventana de herramientas muestra el número
de referencias de cerca el nombre del proyecto, sus tipos, y sus miembros. Todavía se puede hacer doble clic en un elemento para abrir el editor de
código en la línea seleccionada. Si se pasa sobre una referencia, una información sobre herramientas coloreada muestra una vista previa del bloque de
código que hace referencia al objeto o miembro (véase la Figura 11).
24
Figura 11: Colorized Información sobre la herramienta muestra una vista previa del bloque de código referencia a un objeto
Por defecto, todas las referencias Buscar referencias muestra a través de toda la solución. Puede filtrar la lista por los documentos abiertos, el
proyecto actual, el documento actual, y los documentos con los cambios pendientes. También, por defecto, todas las referencias Encontrar grupos
de artículos por proyecto, entonces, por definición, objeto. La Tabla 2 muestra una lista de la agrupación de objetos disponibles se pueden
encontrar en el Agrupar por
caja combo.
Tabla 2: Opciones de agrupamiento para encontrar todas las referencias
Opción Descripción
Definición del proyecto a continuación, Grupos de proyecto, entonces por definición de objeto (por defecto).
Sólo definición Grupos por objeto o definición del miembro, sin la

jerarquía del proyecto.
Definición entonces Proyecto Grupos de definición de objeto, a continuación, por proyecto.
Definición entonces Path Grupos de definición de objeto, y luego por la ruta del archivo
de código que contiene la definición.
Definición, a continuación, Proyecto Ruta Grupos de definición de objeto, a continuación, por el proyecto, y luego
por la ruta del archivo de código.
También puede buscar entre los resultados con el Buscar buscar todas las referencias cuadro de texto y bloquear los resultados actuales haciendo clic Mantenga
Resultados.
25
Navegando código con Ir a
Visual Studio 2017 introduce una nueva función de navegación llamada Ir, que sustituye y mejora una herramienta más popular
conocido como navegar. Para habilitar Ir a, sólo tiene que pulsar Ctrl + T. Una de navegación emergente aparece y automáticamente
se enumeran todas las ocurrencias del identificador de donde estaba el cursor al pulsar Ctrl + T. La figura 12 muestra un ejemplo.
Figura 12: Ir a la venta ocurrencias del identificador especificado
Usted puede refinar su búsqueda escribiendo en la barra de búsqueda. La lista se actualiza automáticamente con cualquier palabra que coincide
con lo que ha escrito. Al igual que IntelliSense, Go To goza de una barra de herramientas en la parte superior que permite la fácil filtrado basado
en el tipo de objeto. Puede filtrar por archivo de código, tipo, método, miembros de objetos, y la línea de código. Con Go To, sólo se puede
aplicar un filtro a la vez. Observe que al hacer clic en los botones de filtro, el cuadro de búsqueda muestra los caracteres especiales antes de
una palabra o identificador. Por ejemplo, la t carácter que precede cualquier palabra en el buscador filtrará la lista por tipo, mientras que el
carácter # filtrará por el método. Otros personajes son compatibles f ( archivos), metro
(miembros), y: (números de línea). Estos son muy útiles. Si usted sabe de antemano qué tipo de objeto o miembro
que está buscando, pueden acelerar la búsqueda.
Ir a la configuración de cuenta que se pueden personalizar. Si hace clic en el Ajustes de la presentación botón en la esquina derecha de la barra de
herramientas, usted será capaz de decidir si se debe mostrar una ficha de vista previa o habilitar una vista detallada. La Figura 13 muestra una vista
personalizada que filtra por tipo y muestra detalles tales como el proyecto, archivo de código, y el número de línea que contiene el tipo seleccionado.
26
Figura 13: Personalización de la vista Ir a
En realidad, Ctrl + T es un acceso directo para el Vaya a todos comando en el Editar menú. El menú Editar tiene Adicionales Para los
comandos (por ejemplo, ir a Tipo y Go To miembros), cada uno asignado a un filtro en la ventana de la herramienta Ir a. Si selecciona uno
de estos comandos, vaya a aparece con el filtro adecuado habilitado. Esto puede acelerar su navegación de código, especialmente si utiliza
los métodos abreviados de teclado proporcionadas.
Estructura de las líneas de guía
Visual Studio 2017 del editor de código introduce una característica conocida como visualizador estructura que estaba previamente disponible en las
herramientas de extensión potencia productividad para Visual Studio 2015. Con esta función activada, el editor llama la estructura de guía de líneas
pequeñas líneas verticales grises cerca de cada bloque de código que hacen que sea más fácil ver la estructura de su código. Si pasa a través de líneas
de guía estructurados, el editor muestra una información sobre herramientas con una vista previa del código de los padres para el bloque actual. Esto se
demuestra en la Figura 14.
Figura 14: Visualización de Estructura Código de Líneas Guía
27
Esta característica es muy útil con los bloques de código largo, y está activado por defecto. Si desea desactivarlo, vaya a Herramientas
> Opciones > Editor de texto, y claro el Mostrar estructura líneas de guía
opción.
análisis de código Roslyn
Junto con Visual Studio 2017, Microsoft es la liberación de C # y Visual Basic 7.0 15 con una versión actualizada de la plataforma .NET
compilador, también conocido como proyecto Roslyn . La plataforma .NET proporciona compilador de código abierto de C # y Visual Basic
compiladores con las API de análisis de código ricos. Con esta plataforma, los compiladores se ofrecen como un servicio y los desarrolladores
pueden aprovechar sus APIs para llevar a cabo una serie de operaciones contra el código fuente. Si desea saber más acerca de Roslyn, se
puede leer el libro electrónico Roslyn Sucintamente (También escrito por mí). A partir de Visual Studio 2015, un gran número de herramientas,
incluyendo el editor de código, ya no son impulsados por el propio IDE; en cambio, que son alimentados por Roslyn. Estas herramientas
incluyen el análisis de código en vivo que detecta problemas mientras se escribe, y refactorización de código. Como se describe en Roslyn
Sucintamente y
Visual Studio 2015 Sucintamente , Cuando el compilador detecta problemas de código a medida que escribe, el editor ofrece la bombilla y acciones
rápidas para solucionar un problema o refactorizar un bloque de código. Visual Studio 2017 tiene algunos pasos hacia adelante, proporcionando
nuevas herramientas de refactorización y una experiencia de codificación mejorada basada en Roslyn.
Más refactorizaciones Roslyn
La nueva versión de Roslyn ofrece refactorizaciones de código interesantes adicionales. La siguiente es una lista detallada de lo que es
nuevo.
Simplificar inicialización de objetos
El primer nuevo refactorización simplifica la inicialización de objetos. Sustituye a una inicialización de objetos basado en asignaciones de
propiedad con otra basada en inicializadores de objeto. La Figura 15 muestra esta refactorización en acción. Observe que cuando el
editor de código detecta un posible refactorización para una inicialización de objetos, subraya la invocación del constructor con tres
puntos grises.
28
Figura 15: El Refactoring inicialización de objetos
Esta refactorización código también proporciona el sangrado adecuado cuando se aplica.
Convertir a cadena interpolado
Otra refactorización muy útil convierte una invocación a string.Format a una cadena interpolada. Esto se muestra en la
Figura 16.
Figura 16: Conversión de string.Format a cadena de interpolación
29
Puede activar esta refactorización, haga clic en el string.Format invocación, no la asignación. Si desea saber más acerca
de la interpolación de cadenas, visite el página de documentación
en MSDN.
Mover el tipo de archivo que coincida
Suponga que tiene una clase que no está definida dentro de un archivo individual sino que se define dentro de un archivo de código que
contiene otras definiciones de tipo o, más generalmente, otro código. Un nuevo refactorización Roslyn le permite moverse rápidamente el
tipo especificado en un nuevo archivo que va a tener el mismo nombre que el tipo. Por ejemplo, la Figura 17 muestra una clase llamada Persona
que se define dentro de Program.cs. Si hace clic Persona, verá una refactorización que ofrece para mover el tipo en un nuevo archivo
llamado Person.cs.
Figura 17: Desplazamiento de una definición de tipo de archivo que coincida en una
Esta característica es muy útil si lo utiliza para definir varios tipos en un archivo de código. La única salvedad es que, si el
archivo de destino ya existe, Visual Studio generará un nuevo archivo y no va a usar la existente. En el ejemplo actual, si
Person.cs ya existe, a continuación, Visual Studio generará person1.cs y colocar el tipo en el archivo recién creado.
30
Sincronización nombre del tipo y nombre de archivo
Si usted tiene una definición de tipo dentro de un archivo cuyo nombre no coincide con el nombre del tipo, un nuevo refactorización simplificará el
trabajo de mantener el nombre del tipo y nombre de archivo en sincronía. Por ejemplo, si tiene una Persona clase definida dentro de un archivo llamado
Human.cs, se puede cambiar el nombre del archivo o cambiar el nombre de la clase a hacer que coincidan. La figura 18 muestra esta refactorización en
la acción, lo que habilita haciendo clic derecho en un nombre de tipo.
Figura 18: Mantener Tipo Nombre y Nombre de archivo de sincronización
La refactorización de cambio de nombre de archivos ofrece para cambiar el nombre del archivo para que coincida con el nombre del tipo. Como
alternativa, cambiar el nombre de ofertas tipo para cambiar el nombre del tipo para que coincida con el nombre del archivo.
Inline a cabo las declaraciones de variables
Nota: Esta refactorización no está disponible en Visual Basic 15.
C # 7.0 presenta una nueva característica conocida como las variables fuera , Que ofrecen la posibilidad de declarar una variable justo en el punto
donde se utiliza como un argumento a cabo. Roslyn ahora ofrece una nueva refactorización para apoyar esta característica, como se muestra en la
Figura 19.
31
Figura 19: Presentación de una variable de Inline Fuera
Con la declaración de variables en línea refactorización, puede simplificar el código que utiliza las variables a cabo la introducción de una
declaración en línea.
El control de análisis en vivo con estilo de código
Con Roslyn, los compiladores pueden reportar problemas de código a medida que escribe, no importa qué tipo de Roslynbased IDE se está
utilizando. Con Visual Studio y antes de Roslyn, el editor de código sólo podría analizar el código de reglas diseñadas en Microsoft. Una de
las mayores ventajas de Roslyn es que le permite presentarse sus propias reglas de análisis (con correcciones y refactorizaciones), y el
compilador informará cuestiones de código que no se adhiere a esas reglas. Mientras que ciertamente tenemos un control total sobre las
reglas que escribimos, antes de Visual Studio 2017 que no tenía control sobre las reglas codificadas en Microsoft, a excepción de deshabilitar
las advertencias. Por ejemplo, en Visual Studio 2015, el compilador de fondo siempre se informa por redundante el uso de la esta y Yo palabras
clave en C # y VB a menos que la palabra clave se utiliza para hacer referencia a un miembro que tiene el mismo nombre que la variable
estamos asignando (por ejemplo, this.name = nombre).
Como otro ejemplo, en Visual Studio 2015, el compilador siempre sugiere que sustituimos los nombres de tipo marco con
las palabras clave correspondientes; por ejemplo, sugiere que utilizamos int
(C #) o entero ( VB) en lugar de System.Int32. Sin embargo, hay un montón de razones por las que podría querer usar esos estilos de codificación.
Con el fin de dar a los desarrolladores la oportunidad de decidir qué estilos de codificación que desea utilizar, con Visual Studio 2017, Microsoft ha
introducido una nueva herramienta llamada estilo de código. Esta herramienta le permite decidir cómo el compilador debe tratar a algunas de
nuestras preferencias de codificación, incluyendo nombres. Se accede a la configuración de estilo de código seleccionando Herramientas >
Opciones > Editor de texto, entonces DO# o Visual Basic, y finalmente el Estilo código nodo. Voy a ofrecer una descripción basada en C #, pero lo
mismo se aplica a Visual Basic (más adelante voy a resumir las preferencias disponibles para ambos). En C #, estilo de código tiene en general, el
formato (C sólo #), y las opciones de nombres.
32
Consejo: Detrás de las escenas, esta característica se basa en la EditorConfig formato de archivo. Si desea
configurar más estilos de código, puede leer esto entrada en el blog desde el
. Equipo NET de Microsoft.
estilo de código general
Los ajustes generales son probablemente las opciones más interesantes para alterar el estilo de código. Ellos le permiten cambiar las
preferencias sobre algunas incorporado en las reglas de codificación. Cada grupo de preferencias le permite especificar la preferencia y el
nivel de gravedad. Si el código no coincide con la preferencia, el compilador reportará una sugerencia, advertencia o de error, dependiendo
del nivel de gravedad que elija. La gravedad predeterminado es Ninguno, lo que significa que el compilador simplemente ignorar la
preferencia e informar nada.
Consejo: Recuerde que el nivel de gravedad de error evitará que la construcción de su proyecto hasta que se resuelva el
problema de código.
Por ejemplo, supongamos que desea utilizar el esta palabra clave al hacer referencia a la propiedad de un objeto y que el
compilador debe reportar una sugerencia si su código no utiliza la palabra clave. La Figura 20 muestra cómo lograr esto.
Figura 20: Cambio de preferencias de estilo de Código
33
Observe cómo se muestra una vista previa de su código en la parte inferior del cuadro de diálogo de la Figura 20, mientras que la figura 21
muestra el resultado de establecer esta preferencia, el compilador informa una sugerencia sobre la asignación de propiedad y sin esta, y la
bombilla ofrece para solucionar el problema.
Figura 21: Cambiar el estilo de código para la esta Palabra clave
Como otro ejemplo, supongamos que desea controlar el estilo de código para el var palabra clave. Más específicamente, supongamos
que se desea evitar el uso var con una función de los tipos y se quiere evitar var
cuando el tipo es evidente a partir de expresiones de asignación. La Figura 22 muestra cómo lograr esto.
34
Figura 22: Cambiar el estilo de código para la var Palabra clave
En el primer caso, el compilador reportará un aviso cada vez que utilice var en lugar de un tipo incorporado, y ofrecerá la solución de
código adecuada, como se muestra en la Figura 23.
Figura 23: compilador detecta y correcciones incorrecto var Uso
35
En el caso de las asignaciones aparentes, la Figura 24 muestra cómo el compilador detecta que la asignación de una instancia de la Persona
tipo a una variable es una asignación aparente. Por lo tanto, el compilador informa la sugerencia de reemplazar var con la explícita Persona
escribir, ofreciendo la solución adecuada a través de la bombilla.
Figura 24: compilador detecta una inadecuada var Uso con una asignación aparente
Las Tablas 3 y 4 resumen algunas de las preferencias disponibles para C # y Visual Basic, respectivamente. Recuerde que una
vista previa de código para cada estilo se muestra en la opciones diálogo.
Tabla 3: Preferencias estilo de código para C #
Grupo de Preferencia Descripción

preferencias
'esta.' Calificar el acceso de campo con 'esto' Establece si se debe preferir la esta
preferencias palabra clave para calificar el acceso a los campos.
'esta.' Calificar acceso a la propiedad con Establece si se debe preferir la esta

preferencias 'esto' palabra clave para calificar el acceso a propiedades.
'esta.' Calificar el acceso método con Establece si se debe preferir la esta

preferencias 'esto' palabra clave para calificar el acceso a los métodos.
'esta.' Calificar el acceso evento con 'esto' Establece si se debe preferir la esta
preferencias palabra clave para calificar el acceso a los eventos.
tipo Para los locales, los parámetros y los Establece si se debe preferir el tipo predefinido (por ejemplo,
predefinido miembros int, doble) sobre el tipo marco (por ejemplo, System.Int32,
preferencias System.Double)
con variables locales, los parámetros del método, y miembros de
objetos.
36
preferencias
tipo Para expresiones de acceso Establece si se debe preferir el tipo predefinido sobre el
predefinido miembro tipo de marco al tener acceso a miembros de tipo.
preferencias
'Var' Para los tipos incorporados Establece si se debe preferir un tipo explícito en lugar de la var de
preferencias palabras clave con tipos incorporadas, tales como int, string,
doble, etcétera
'Var' Cuando el tipo de variable es Establece si se debe preferir un tipo explícito en lugar de la var palabra
preferencias aparente clave cuando el tipo puede ser fácilmente descubierto por la
asignación de una expresión.
'Var' En otra parte Establece si se debe preferir un tipo explícito en lugar de la var palabra
preferencias clave en todos los demás casos.
preferencias bloque Prefiero tirantes, Para los métodos, para los Establece si los bloques de código deben ser
de código constructores, Para los operadores, Para las implementadas con un cuerpo de bloque o de un órgano de
propiedades, Para indizadores, Para expresión (es decir, con las expresiones lambda).
accessors
preferencias de Prefiero inicializador de objeto Establece si se debe preferir un inicializador de objeto cuando
expresión una instancia de un objeto y poblar sus miembros. Cuando se
informa, este invoca la refactorización objeto de inicialización
simplificar se describe en la sección anterior.
preferencias de Prefiero inicializador de colección Establece si se debe preferir un inicializador de colección cuando
expresión una instancia de una colección de objetos. Cuando se informó, el
editor ofrece la solución adecuada.
preferencias de Prefiero coincidencia de patrones más Establece si se debe hacer cumplir el código de verificación fundido con la
expresión 'es' con cheque 'fundido' coincidencia de patrones.
preferencias de Prefiero coincidencia de patrones sobre Establece si se debe utilizar el código de coincidencia de patrones en
expresión 'como' con cheque 'nulo' lugar de utilizar el como operador de conversión para los cheques nulos.
preferencias de Prefiero nombre tupla explícita Tuplas en C # 7.0 permiten nombres implícitos. Esta opción establece
expresión si el código debe utilizar nombres de tupla explícitas o implícitas.
37
preferencias
preferencias Prefiero declaración de variables Establece si se debe preferir el uso de declaración de variables
variables en línea en línea. Cuando se informa, este invoca la línea cabo
refactorización declaración de variables se describe en la
sección anterior.
'Nulo' Prefiero tirar expresión Con cheques nulos, establece si se debe preferir el uso de la
comprobar' nueva expresión tiro característica de C # 7.0 con el operador
nulo coalescencia (??) en lugar de comparar las variables de nulo.
'Comprobación nulo' Prefiero delegado condicional Con cheques nulos, establece si se debe preferir el
llamada operador nulo condicional (?.) Y los delegados Invocar método
sobre la evaluación de un objeto con el! = nulo expresión.
'Comprobación nulo' Prefiero unirse expresión con cheques nulos, establece si debe
prefieren el operador coalescente (??) en lugar de
expresiones basado en el operador condicional (?).
'Comprobación nulo' Prefiero propagación nulo Con cheques nulos, establece si se debe preferir la
propagación nulo en lugar de comparaciones
condicional basada en el operador condicional (?).?:.
Tabla 4: Preferencias estilo de código de Visual Basic

preferencias
'Yo.' Calificar el acceso de Establece si se debe preferir la Yo palabra clave para calificar el acceso a los
preferencias campo con 'Yo' campos.
'Yo.' Calificar el acceso a la Establece si se debe preferir la Yo palabra clave para calificar el acceso a
preferencias propiedad 'Me' propiedades.
'Yo.' Calificar el acceso Establece si se debe preferir la Yo palabra clave para calificar el acceso a los
preferencias método con el 'Yo' métodos.
'Yo.' Calificar el acceso Establece si se debe preferir la Yo palabra clave para calificar el acceso a los
preferencias evento con 'Me' eventos.
38
preferencias
tipo Para los locales, los Establece si se debe preferir el tipo predefinido (por ejemplo,
predefinido parámetros y los miembros Entero, Fecha) sobre el tipo marco (por ejemplo,
preferencias System.Int32, System.DateTime) con variables locales, los parámetros del
método, y miembros de objetos.
tipo Para expresiones Establece si se debe preferir el tipo predefinido sobre el tipo de marco
predefinido de acceso al tener acceso a miembros de tipo.
preferencias miembro
preferencias de Prefiero inicializador Establece si se debe preferir un inicializador de objeto cuando una instancia
expresión de objeto de un objeto y poblar sus miembros. Cuando se informa, este invoca la
inicialización refactorización objeto simplificar se describe en la sección
anterior.
preferencias de Prefiero inicializador de Establece si se debe preferir un inicializador de colección cuando una instancia de
expresión colección una colección de objetos. Cuando se informó, el editor ofrece la solución adecuada.
preferencias de Prefiero nombre tupla Tuplas en Visual Basic 15 permiten nombres implícitos. Esta opción establece si
expresión explícita el código debe utilizar nombres de tupla explícitas o implícitas.
'Nada' Prefiero unirse Establece si se debe preferir llamar al Si operador con la evaluación de
comprobación expresión cortocircuito para los cheques nulos.
'Nada' Prefiero Establece si se debe preferir el operador condicional nula?. para

comprobación propagación nulo cheques nulos.
Esta característica es muy útil, especialmente si usted encuentra algunas de las sugerencias por defecto del compilador para ser
molesto.
estilo de código de formato
Estilo de formato de código está disponible sólo para C #. Esto tiene sentido porque el objetivo principal de formato es controlar el formato
automático y la sangría de llaves y el código que es o debería ser dentro de llaves a medida que escribe. El formateo también le permite
controlar la forma en que algunos bloques de código o declaraciones deben añadirse a construcciones específicas. Todas las opciones
disponibles tienen nombres fácil de entender y la opciones de diálogo muestra una vista previa de cómo se verá el código con una opción
particular seleccionado. A modo de ejemplo, la Figura 25 muestra cómo una definición de propiedad se ve con el Deja bloque con sencillo
en línea opción seleccionada (bajo la Envase nodo), mientras que la Figura 26 muestra cómo la misma definición de propiedad se verá con
esa opción no seleccionada.
39
Figura 25: bloques de código, debe estar en una sola línea
40
Figura 26: bloques de código, debe estar en varias líneas
Nombrando estilo de código
Las preferencias de estilo de código de nomenclatura abordan .NET convenciones de nomenclatura para los tipos y miembros. Con las
especificaciones de denominación, se puede controlar la forma en que el compilador debe informar sobre cuestiones de código que no se
adhiere a las convenciones de nombres especificados. Por ejemplo, si el nombre de una interfaz no comienza con YO, el compilador reportará una
sugerencia para fijar su nombre. Cada especificación puede tener un estilo y nivel de gravedad. El nivel de gravedad puede ser None,
sugerencia, advertencia o de error. Hay tres estilos incorporados y se resumen cuatro incorporados en las especificaciones-éstos en las Tablas 5
y 6, respectivamente. Por defecto, todas las especificaciones tienen el nivel de gravedad de sugerencias.
Tabla 5: incorporado en el nombramiento de Estilos
Nombre de estilo Descripción
Comienza con I El nombre del tipo o miembro seleccionado en la especificación a la que está
asignado debe comenzar con YO.
Pascal Case El nombre del tipo o miembro seleccionado en la especificación a la que está asignado
debería seguir el caso Pascal convención de nomenclatura.
41
Tabla 6: incorporado en la nomenclatura Especificaciones
nombre de la especificación Descripción
Interfaz Determina que el nombre de una interfaz debe seguir la regla de denominación asignada
en la columna de estilo. El estilo predeterminado es Comienza con I.
tipos Determina que un nombre de tipo debe seguir la regla de denominación asignada en la
columna de estilo. El estilo predeterminado es Pascal Case.
Los no miembros de campo Determina que los miembros de objetos diferentes campos que deben seguir la regla de
denominación asignada en la columna de estilo. El estilo predeterminado es Pascal Case.
Nota: Yo recomiendo encarecidamente que no cambie estos cuatro especificaciones. Reflejan

algunos de los más importantes nomenclatura general en .NET y debe dejarse como están.
La figura 27 muestra la configuración predeterminada para las opciones de estilo de código de denominación.
Figura 27: Ajustes por defecto en el estilo de código de nomenclatura
42
Usted tiene un control significativo sobre la configuración de nombres. De hecho, se puede añadir sus propias especificaciones y estilos, y se
puede combinar varios estilos para la misma especificación. Puede incluso editar las especificaciones y estilos existentes haciendo clic Manejo
de especificaciones y Administrar los estilos. Por ejemplo, supongamos que desea añadir una nueva convención de nomenclatura para las
enumeraciones privadas y desea que el estilo sea el caso camello. Para lograr esto, haga clic Manejo de especificaciones. Esto mostrará la
lista completa de las especificaciones activos (véase la Figura 28).
Figura 28: la lista de especificaciones disponibles
Para cada especificación, puede hacer clic Editar ( con el icono de lápiz) para cambiar sus propiedades o
Borrar para quitarlo (no recomendado).
Tip: Modificación de una especificación existente se abrirá el mismo cuadro de diálogo Símbolo especificaciones
descritas en breve (y visible en la Figura 29).
43
Como se puede ver, una especificación para enum tipos ya existe, pero digamos que desea agregar uno específicamente para
enumeraciones privadas. Hacer clic Añadir ( + el icono verde). En el símbolo Significado
diálogo que aparece, verá una lista de los tipos disponibles, modificadores y descriptores de acceso. Asegúrese de que sólo enumeración y privado se
seleccionan, a continuación, asignar la Las enumeraciones privada en el título Símbolo Significado Título cuadro de texto (ver Figura 29) y, por último,
haga clic DE ACUERDO.
Figura 29: Creación de una especificación personalizada
Hacer clic DE ACUERDO de nuevo para cerrar el Manejo de Especificaciones diálogo. En este punto, la nueva especificación será incluido en la lista de
nombres de estilo de código. Ahora es necesario crear un nuevo estilo, así que haga clic Administrar los estilos. los Administrar estilos de
nomenclatura diálogo mostrará la lista de los estilos actuales, que contiene los tres estilos que se describen en Tabla 5 . Hacer clic Añadir para agregar
una nueva. En el Estilo de nombres de diálogo (ver Figura 30), proporcionar un título para el nuevo estilo, tales como Camel caso, entonces
seleccionar la Nombre camello Caso opción de la Capitalización caja combo. Como se puede ver, también tiene la opción de especificar un prefijo, un
sufijo, y un separador de palabra (no es necesario en este caso).
44
Figura 30: Creación de un estilo personalizado
Hacer clic DE ACUERDO para cerrar el diálogo de nombres de estilo, a continuación, haga clic DE ACUERDO para cerrar el cuadro de diálogo Estilos de
nomenclatura. En este punto, usted será capaz de asignar el nuevo estilo para la especificación creada anteriormente, como se muestra en la Figura 31
(aviso de que un nivel de gravedad de la alerta ha sido también asignado).
Figura 31: Asignación de un estilo personalizado a una especificación de encargo
45
Si desea ver el resultado de su trabajo en la acción, debe dar un paso más. Debido a que la especificación Tipos incluye todos los tipos de
acceso con ninguna visibilidad, debería editar esta memoria y eliminar el descriptor de acceso privado de la lista. Puedes usar Las figuras
28 y 29 como una referencia. Por supuesto, lo hacemos sólo para fines de demostración, pero las especificaciones predeterminadas no se
debe cambiar. Sin embargo, con estas especificaciones y estilos personalizados, el compilador ahora detecta una violación de la regla de
nomenclatura para las enumeraciones privadas, muestra un mensaje de advertencia, y ofrece la solución adecuada, como se muestra en
la Figura 32.
Figura 32: Detección de Naming Custom Reglas Violaciónes y un Fix Código
Por lo tanto, usted no está limitado a la creación de reglas de nomenclatura de encargo que serán comprobados por el motor de análisis en vivo, sino que
también tendrá correcciones de código de violaciónes, que es realmente sorprendente.
46
mejoras de edición para C ++ y F #
Visual Studio 2017 introduce mejoras en la experiencia de edición de código para C ++ y C #, también. Para C ++, las
funciones como IntelliSense, Ir a definición, y encontrar todas las referencias ahora se basan en una base de datos SQLite
que almacena la información que necesita el IDE con el fin de moverse rápidamente entre las líneas de código, y que mejora
considerablemente el rendimiento. Además, el editor de código para C ++ proporciona ahora dos nuevas refactorizaciones: el
cambio de la firma y la función de extracción. La primera refactorización permite cambiar más rápidamente la firma de un
método, mientras que el segundo permite encapsular un bloque de código en una función. Con F #, el editor de código ofrece
ahora una mejor IntelliSense con mejores terminaciones y filtros, junto con el tipo de coloreado. Además, el editor de código F
# ahora se construye en Roslyn áreas de trabajo, y muchas características están ahora alimentado por Roslyn, incluyendo Ir a
definición,
Microsoft ha aumentado la productividad del editor de código para C # y Visual Basic en Visual Studio 2017 mediante la
inversión en IntelliSense, navegación de código, e integrado de análisis de código Roslyn. IntelliSense tiene un mejor
rendimiento y permite el filtrado de tipo, lo que hace que sea más fácil de usar los objetos y los miembros que necesita.
Para la navegación de código, Encuentra todas las referencias ahora se presenta listas de objetos agrupados con la
coloración de sintaxis. Ir a es un reemplazo mejorado de navegar, con filtrado de tipo y búsqueda rápida entre las
grandes bases de código. Por último, las líneas de guía estructura nos ayudan a entender a la que pertenece el bloque
de código un fragmento. Con el análisis de código en vivo alimentado por Roslyn, nuevas refactorizaciones están
disponibles para C # y Visual Basic, y ahora se puede controlar estilos y reglas de nomenclatura codificados en
Microsoft con las nuevas características de estilo de código.
47
Mejoras en el capítulo 4 XAML
los Lenguaje de Marcado Extensible Application ( XAML) es el lenguaje de diseño de la interfaz de usuario de Windows Presentation
Foundation (WPF) y aplicaciones de Windows Plataforma universal (UWP). Por lo tanto, es crucial para Microsoft. En Visual Studio
2017, el utillaje para XAML se ha mejorado de forma espectacular. En cuanto al rendimiento, el cambio entre pestañas en el editor
de código XAML es más de un 90% más rápido en algunos casos, y se han hecho muchas inversiones para evitar demoras al
escribir el marcado XAML en el editor. Además, muchos otros se han realizado mejoras a la experiencia de codificación y las
herramientas de diagnóstico. En este capítulo se describen estas mejoras, que muestra cuánto más productivo que puede estar en
Visual Studio 2017. Si desea hacerlo por uno mismo, sólo tiene que crear un espacio en blanco o uwp proyecto WPF y abrir un
archivo .xaml.
Nota: En este capítulo se describen las características que son comunes a ambos WPF y UWP.
Capítulo 8, “Visual Studio 2017 para el desarrollo móvil” abordará mejoras adicionales que se dirigen a
UWP. Los temas tratados en este capítulo no están disponibles para XAML para Xamarin.Forms.
XAML Editar y continuar
Una de las novedades más importantes de la herramienta XAML en Visual Studio 2017 es XAML Editar y continuar. Esta característica nos
permite editar código XAML mientras la aplicación se está ejecutando en la configuración de depuración. La aplicación se reflejará de inmediato
esas ediciones sin la necesidad de romper la ejecución de la aplicación y reiniciar después de hacer algunas modificaciones. La Figura 33
muestra cómo puede editar los valores de propiedad en el modo de depuración (demostrado por el color naranja de la barra de estado en la
parte inferior de la carcasa principal Visual Studio).
48
Figura 33: Modificación de XAML en tiempo de ejecución con Editar y continuar
No está limitado a los controles de edición o paneles de propiedad valores también se pueden añadir nuevos controles, nuevos paneles,
y todo lo que pueda necesitar para mejorar su interfaz de usuario. Se puede combinar el uso de esta función con el árbol visual en vivo y
Windows Live Propiedad Explorer para obtener una experiencia mejorada. Editar y continuar ha sido una característica muy solicitada y
por fin está disponible para todas las ediciones de Visual Studio 2017.
XAML mejoras editor de código
Más a menudo que no, que va a escribir código XAML manualmente con el fin de diseñar o al menos para afinar la interfaz de usuario
de una aplicación WPF o UWP. Por esta razón, Microsoft ha introducido mejoras adicionales en el editor de código XAML que mejorará
en gran medida su experiencia de codificación. Entre otros, el editor XAML tiene ahora la líneas de guía estructura característica que
examinamos en Capítulo 3 . Las características adicionales abordan IntelliSense y el código de refactorización, y que se describen en
los párrafos siguientes.
49
Nota: Las cifras en este capítulo se han capturado de un proyecto UWP, pero lo mismo se aplica a
WPF.
Navegando código con Ir a
En Capítulo 3 , Nos fijamos en la función Ir a, lo que hace que la navegación código sea más fácil y más rápido. Esto también está
disponible para el editor de código XAML y se puede activar pulsando Ctrl + G.
filtrado de IntelliSense
IntelliSense para XAML se ha actualizado para mostrar sólo aquellos miembros que mejor partido de lo que escribe. Además, si escribe
sólo las letras mayúsculas de un nombre de control, IntelliSense mostrará la lista de los nombres de los controles completos que
coinciden con esas letras en mayúsculas. Por ejemplo, si escribe SV en UWP, IntelliSense filtrará la lista de terminación mostrando sólo el ScrollViewer
y Vista dividida
nombres de los elementos (véase la figura 34).
Figura 34: IntelliSense Filtrado
espacios de nombres de refactorización
Numerosas mejoras se han introducido para una mejor gestión de los espacios de nombres XAML. Estos incluyen características que anteriormente
estaban disponibles para C # y Visual Basic, como el cambio de nombre en línea, la resolución de los espacios de nombres que faltan, y la
eliminación de espacios de nombres redundantes.
Extracción y clasificación de espacios de nombres
El editor de código XAML detecta espacios de nombres redundantes por su presentación con una coloración de sintaxis más ligero, exactamente
como con C # y Visual Basic desde Visual Studio 2015. Usted puede quitar fácilmente espacios de nombres redundantes con la ayuda de la
bombilla como se muestra en la Figura 35.
50
Figura 35: Eliminación de espacios de nombres redundantes
También puede eliminar rápidamente los espacios de nombres redundantes y ordenar los espacios de nombres restantes haciendo clic derecho en el
código XAML luego seleccionando Retire y ordenar espacios de nombres, o pulsando Ctrl + R, a continuación, Ctrl + G.
cambiar el nombre de espacio de nombres inline
La característica en línea de cambio de nombre fue introducido por primera vez en Visual Studio 2015 para el C # y Visual Basic idiomas, y permite cambiar el
nombre de un símbolo directamente en el editor, sin cuadros de diálogo modales. En Visual Studio 2017, esta característica ahora llega al editor de código
XAML, proporcionando una opción para cambiar el nombre de los espacios de nombres de manera más eficiente. Puede hacer clic en el nombre de un espacio
de nombres, a continuación, seleccione
Rebautizar. Esto también resaltar todas las referencias a los espacios de nombres seleccionados, como se muestra en la Figura 36.
Figura 36: Activación de Inline Cambiar nombre en espacios de nombres
Simplemente escriba el nuevo nombre en cualquier ubicación resaltada y se va a aplicar a todas las referencias en toda la solución (véase
la Figura 37).
51
Figura 37: Cambio de nombre de espacios de nombres mientras se escribe
Al igual que con C # y Visual Basic, también puede incluir referencias de espacio de nombres dentro de los comentarios y las cadenas de un cambio de nombre
consistente.
La resolución de los espacios de nombres que faltan
Nota: Con el fin de demostrar esta característica, he añadido el

Microsoft.Toolkit.Uwp.Controls NuGet paquete para un proyecto uwp en blanco. Sin embargo, se aplica a cualquier
control en cualquier biblioteca y espacio de nombres, tanto a uwp y WPF.
Con frecuencia tenemos que añadir una referencia a una biblioteca que ofrece algunos controles, que pueden ser un complemento de Microsoft o una
biblioteca de terceros. Sin embargo, es posible que no sepa qué espacio de nombres XAML expone el control, lo que puede resultar en la pérdida de
tiempo buscando el espacio de nombres adecuado y añadiendo su declaración. En Visual Studio 2017, el editor de código puede resolver fácilmente los
espacios de nombres que faltan, la adición de la declaración correspondiente en su nombre. La figura 38 muestra cómo se puede escribir el nombre de
un control con la bombilla y luego sugieren una acción rápida para añadirlo, falta de declaración de espacio de nombres adecuado.
Figura 38: La bombilla Sugiere Quick Acciones para espacios de nombres que faltan
52
Como resultado de la acción rápida, Visual Studio agrega el espacio de nombres XAML adecuada. En este caso particular, se
añade una xmlns: controles directiva que apunta a un espacio de nombres llamado Microsoft.Toolkit.Uwp.UI.Controls, como se
muestra en la Figura 39.
Figura 39: Espacio de nombres Añadido y solucionado el problema
Observe que el identificador de la Directiva ( controlar en este caso) se genera en base al nombre de espacio de nombres .NET. A continuación, puede
utilizar el cambio de nombre en línea para proporcionar un identificador diferente y actualizar automáticamente todas las referencias.
Diagnóstico XAML
Visual Studio 2017 incluye una característica llamada XAML Diagnósticos. Esta característica se introdujo por primera vez con Visual Studio 2015
Actualización 2 bajo el nombre XAML En la aplicación del menú, pero que merece alguna explicación, especialmente si usted es nuevo en el
entorno de desarrollo de Visual Studio. XAML Diagnóstico consiste en una barra de herramientas negro, plegable que aparece cuando se depura
una aplicación WPF o UWP. La Figura 40 muestra esta barra de herramientas a través de una aplicación muy simple.
Figura 40: El XAML Diagnóstico Barra de herramientas
53
Consejo: El menú de In-App está activado por defecto. Si desea desactivarlo, vaya a Herramientas > Opciones > depuración, y claro el Mostrar
herramientas de tiempo de ejecución en la aplicación opción.
El Menú En la aplicación puede ser minimizado, lo que es útil para evitar partes superpuestas de la interfaz de usuario, pero por ahora, no la deje
abierta. El menú tiene cuatro botones, cada uno se describe en los siguientes párrafos (a partir de izquierda a derecha).
Ir a Live Visual Árbol
Como su nombre indica, este botón simplemente abre la ventana vivo Visual herramienta de árbol. Le sugiero que fijar la ventana de
Visual vivo árbol para que inmediatamente se ve el resultado de los otros botones. Más información sobre el árbol visual en vivo se
puede encontrar en el documentación de MSDN .
Activar selección
Este botón permite seleccionar controles de la interfaz de usuario. Cuando se selecciona un control, que está rodeado con un
borde rojo, y la ventana de Visual árbol vivo muestra automáticamente el control seleccionado en el árbol visual. La figura 41
muestra un ejemplo.
Figura 41: Activación de Selección de elementos en XAML Diagnóstico
54
Esto es útil para el enfoque más precisamente en un control específico o elemento de interfaz de usuario, incluyendo elementos primitivos en el árbol
visual.
Adornos Componentes de la pantalla
Este botón le permite resaltar la superficie de un control o elemento de interfaz de usuario. Si se combina con Activar selección, un elemento
se pone de relieve y seleccionado. La selección también se refleja en la ventana de Visual vivo árbol. Esto es útil para la comprensión de los
delimitadores de un control. La Figura 42 muestra un ejemplo basado en la combinación de los dos botones.
Figure 42: Displaying Layout Adornments
Pista activa Elemento
La pista activa del elemento es similar para permitir la selección, ya que permite la selección de un control y que refleja la selección en
el árbol visual en vivo, pero se debe tener en cuenta que sólo permite la selección de controles que pueden recibir el foco (por ejemplo,
Caja de texto controles).
Debido a su importancia en la Fundación Universal de la plataforma Windows y Windows Presentation, el editor de

código XAML ha recibido una serie de mejoras en Visual Studio
2017. Con Editar y continuar, ahora se puede modificar el árbol visual y ver los cambios mientras la aplicación está en modo de depuración.
IntelliSense ha mejorado filtrado, Ir a le permite navegar rápidamente su margen de beneficio, y las nuevas refactorizaciones se han
introducido para apoyar la gestión del espacio de nombres. Sin embargo, Visual Studio 2017 no es simplemente el medio ambiente para los
idiomas gestionados y XAML. Es el entorno de desarrollo para cualquier desarrollo en cualquier plataforma. En el siguiente capítulo, usted
descubrirá nuevas características sorprendentes para los desarrolladores que no trabajan con las soluciones y proyectos de MSBuild.
55
Capítulo 5 Trabajar con las soluciones, carpetas,
y Lenguas
Visual Studio 2017 introduce cambios al modelo de solución y la forma en que el IDE gestiona proyectos. Esto trae un mejor rendimiento
y fiabilidad, especialmente con soluciones de gran tamaño. Visual Studio 2017 también es compatible con un mayor número de idiomas y
los archivos de código, independientemente del sistema de proyectos a la que pertenecen. Todas estas golosinas se describen a fondo
en este capítulo.
Ligera carga Solución
A menudo, las aplicaciones empresariales consisten en soluciones muy grandes, a veces con docenas de proyectos. Sin embargo, la carga de
una solución muy grande puede resultar en un impacto negativo en el rendimiento general de Visual Studio. Por esta razón, Visual Studio 2017
ha introducido una nueva característica llamada Ligera Solución de carga. Esta característica optimiza el proceso de carga de soluciones muy
grandes, proporcionando una mejor capacidad de respuesta y el rendimiento. Esta función no está activada por defecto, por lo que se puede
activar manualmente, vaya hasta Herramientas > Opciones > Proyectos y soluciones, y luego seleccionando Solución de carga ligera ( véase
la Figura 43).
Figura 43: Activación de peso ligero de carga Solution
56
Debe comprender las razones por las que esta característica no está activado de forma predeterminada antes de usarlo:
• Se beneficia del uso de esta función únicamente con soluciones de gran tamaño.
• Está optimizado para trabajar con soluciones hechas de C # / VB proyectos o una combinación de proyectos de C ++ y C #. No todos los
tipos de proyectos se benefician de esta característica.
• Visual Studio 2017 puede detectar automáticamente si la carga de una solución dada puede ser optimizado con esta
característica. En este caso, se le pedirá con un mensaje y solicitar su autorización para habilitar la función para usted.
Detrás de las escenas, ligeros retrasos solución de carga que cargan algunos proyectos hasta que realmente los necesitan. Esto implica que
algunas características, como la refactorización de código, navegación de código, o el cambio de nombre en línea, pueden requerir algunos
milisegundos adicionales la primera vez que se invoca. En conclusión, ligero de carga Solución es una adición muy útil, pero sólo con grandes
soluciones hechas de proyectos de C # / VB o con soluciones mixtas de C # / C ++.
soporte de idiomas ampliada
Fuera de la caja, Visual Studio 2017 proporciona soporte integrado para un conjunto más amplio de lenguas que las versiones
anteriores. Este apoyo consiste en la coloración de sintaxis, fragmentos de código, la navegación y la finalización de código a través del
editor de Visual Studio núcleo, lo que significa que está disponible incluso si no se han instalado las cargas de trabajo. Si instala las
cargas de trabajo que se dirigen a los lenguajes específicos (por ejemplo, desarrollo de escritorio .NET que se dirige a C # y VB), los
idiomas recibirán un apoyo más amplio, tales como, pero no limitado a, IntelliSense, bombillas y acciones rápidas, depuración, etc. en. El
valor de esta característica se demuestra en la siguiente sección, “Abrir carpeta:. El uso de cualquier código base” Mientras tanto, echar
un vistazo a la tabla 7, que resume la lista de idiomas y características soportadas por idioma.
Tabla 7: Idiomas compatibles y características de Visual Studio 2017
Caracteristicas idiomas
Sólo coloreado de sintaxis y finalización Por lotes, Clojure, CoffeeScript, CSS, estibador, F #, INI, Jade, JSON,
de código MENOS, Hacer, de rebajas, Objective-C, PowerShell, Python, Rust,
ShaderLab, SQL, YAML
Los fragmentos de código, coloreado CMake, maravilloso, HTML, Javadoc, Lua, Perl, R, Ruby, ShellScript,
de sintaxis, y la finalización de código Swift, XML
Ir a, fragmentos de código, coloreado de C ++, C #, Go, Java, JavaScript, PHP, mecanografiado, Visual Basic
sintaxis, y la finalización de código
Mediante el apoyo a estos idiomas, se puede trabajar con el código fuente para diferentes plataformas y aprovechar las características de edición
evolucionadas-incluso cuando no hay cargas de trabajo instalados. Si usted es impaciente, puede intentar abrir los archivos de código individuales en
cualquiera de los idiomas soportados, pero la ventaja más grande está trabajando con las carpetas. La siguiente sección proporciona algunos
ejemplos prácticos.
57
Abrir carpeta: El uso de cualquier código base
Muchos entornos de desarrollo tienen su propio sistema de proyectos, y Visual Studio no es una excepción. Un proyecto contiene todo
lo necesario para construir una aplicación, incluyendo los archivos de código fuente, las referencias a bibliotecas externas, activos y
metadatos. Microsoft Visual Studio siempre ha tenido su propio sistema de proyectos patentada basada en soluciones (archivos .sln) y
proyectos con el
. xxproj extensión, donde xx representa la plataforma orientada al desarrollo, el lenguaje de programación utilizado, o ambos. Una solución
puede ser considerado como un conjunto de proyectos, y en la terminología .NET que se refiere a menudo como una solución de MSBuild,
porque MSBuild.exe es la herramienta Visual Studio utiliza para producir una aplicación que recopila todos los proyectos en una solución de el
orden correcto. la ambición de Visual Studio 2017 es ser el entorno de desarrollo para cualquier desarrollador en cualquier plataforma, por lo
que toma un paso importante hacia adelante mediante el apoyo a un gran número de idiomas non-.NET (ver Tabla 7 ). Visual Studio 2017
también es compatible con las carpetas de trabajo; esto significa que puede abrir las carpetas en el disco que contiene varios archivos de
código y de activos y Visual Studio va a organizar de la mejor manera posible en ese entorno. Esto hace que Visual Studio independiente de
cualquier sistema de proyectos de propiedad (a excepción de las soluciones, por supuesto). Se carga todos los archivos de código en una
carpeta como un surtido suelta, proporcionando una visión estructurada mediante la organización de archivos y subcarpetas en una carpeta raíz
para facilitar la navegación a través Explorador de la solución.
La carpeta raíz es en realidad el nombre de la carpeta que se abrió. Veamos un par de ejemplos.
La creación de la demo
Para los ejemplos, voy a utilizar un proyecto de código abierto llamado Haikunator agradable, que proporciona funciones que generan
nombres de subdominios al azar para el Heroku plataforma. Este proyecto está disponible en varios lenguajes de programación y sin
sistema de proyectos de propiedad, por lo que es perfecto para nuestras necesidades. Voy a estar utilizando dos versiones: la versión
escrita en Go y la versión escrita en Python. El primer ejemplo se utiliza para mostrar las capacidades del editor de base de Visual
Studio, y el segundo ejemplo se utiliza para demostrar una amplia compatibilidad con el idioma con el depurador e IntelliSense. Dicho
esto, siga estos pasos:
1. Ir a github.com/Atrox/haikunatorgo para la versión de Go.

2. Haga clic Clon o descarga, entonces Descargar ZIP.
3. Extraer el contenido del archivo .zip descargado en una carpeta de su elección.
4. Ir a github.com/Atrox/haikunatorpy para la versión de Python, a continuación, repetir los pasos dos y
Tres.
Tomar nota de las carpetas en las que extrae tanto .zip archivos, ya que se utilizarán en breve.
58
soporte de lenguaje Basic en Visual Studio 2017
Nuestro primer ejemplo se basa en la versión del proyecto Haikunator escrito con el lenguaje de programación Go. En Visual Studio
2017, seleccione Archivo > Abrir > Carpeta. Navegar por el disco hasta que encuentre la carpeta en la que extrajo el código, a
continuación, haga clic Seleccione la carpeta. Después de unos segundos, Explorador de la solución mostrará la carpeta raíz para la
navegación y los archivos dentro de esa carpeta (ver Figura 44). Si hace doble clic en cualquiera de los archivos con la extensión .go,
verá cómo Visual Studio 2017 ofrece la coloración sintaxis de este lenguaje soportado incluso si no se han instalado las cargas de
trabajo e incluso si el idioma actual no pertenece a la familia .NET (véase la Figura 44).
Figura 44: Abrir una carpeta y modificar cualquier archivo de código compatibles
Además, se obtiene características de navegación de código como el ir y líneas de guía de la estructura como se muestra en la Figura 45, donde
se puede ver cómo la lista de elementos se puede filtrar a medida que escribe.
59
Figura 45: Características de la navegación en el Editor de Código Núcleo de Visual Studio
Por cada lenguaje soportado, también puede obtener la finalización de código, una característica que hace que la escritura y la edición de código más
rápido y más fácil. La figura 46 muestra un ejemplo.
Figura 46: Código de finalización Simplifica Código de Escritura
60
Algunos idiomas, como Go, también apoyan TextMate fragmentos de código, que están disponibles a través de la finalización de código
emergente. Los fragmentos de código pueden ser reconocidas a través del icono de una hoja en blanco (véase la Figura 46). Por ejemplo, si
selecciona la en eso fragmento y luego pulse Lengüeta, el editor de código inserta un trozo función llamada en eso, como se muestra en la Figura
47.
Figura 47: Inserción de fragmentos de código
Observe cómo los aspectos más destacados editor de código en el código de color amarillo que deben ser reemplazados con su código. Recuerde que
el código de fragmentos no están disponibles para todos los idiomas, pero se puede hacer referencia a Tabla 7 como una referencia rápida disponibilidad
de esta función. Lo importante a destacar aquí es que usted tiene todo lo que cabe esperar de un editor de código evolucionado independientemente del
idioma, sistemas del proyecto, y las cargas de trabajo instalados.
Nota: Código de finalización no es IntelliSense. Esta es una aclaración importante. IntelliSense es una herramienta
evolucionada, normalmente impulsado por un compilador de fondo o por una base de datos que permite la realización de un IDE
para mostrar y los elementos del grupo basado en tipos, miembros, identificadores, y así sucesivamente. No es de extrañar,
IntelliSense en Visual Studio está disponible únicamente a un número restringido de lenguas que tienen un amplio apoyo
proporcionado por las cargas de trabajo y herramientas específicas. finalización de código es más limitada, a menudo basada
en una pequeña lista integrada de las palabras clave y en los literales que el editor detecta en el código, pero es, de hecho, a
disposición de cualquier idioma.
Amplia compatibilidad con el idioma a través de las cargas de trabajo y herramientas
Para algunos idiomas, Visual Studio 2017 permite la adición de un amplio apoyo a través de las cargas de trabajo específicas de
instalación o herramientas de terceros. Piense en Python, que es un lenguaje de programación muy popular. El editor de Visual Studio
núcleo proporciona soporte básico para ello, incluyendo la coloración de sintaxis y finalización de código. Sin embargo, Visual Studio
2017 permite ejecutar programas externos en contra de su código fuente; esto significa que si se instala el intérprete de Python , Se puede
ejecutar el código de Python desde el entorno de desarrollo.
61
Consejo: La última frase se aplica a todos los idiomas soportados, no sólo Python.
En pre-versiones de Visual Studio 2017, Microsoft también incluyó una carga de trabajo de instalación específica para el desarrollo de
Python que incluía la integración depurador y otras herramientas mejoradas para trabajar con Python desde el IDE. Para RTM, la carga
de trabajo Python ha sido retirado del instalador de Visual Studio. Visual Studio Tools para Python para Visual Studio 2017 se ofrecerán
por separado y está previsto para ser lanzado pocos días después de Visual Studio 2017 alcanza el hito de RTM. Por lo tanto, el
siguiente ejemplo basado en la versión Python del proyecto Haikunator se basa realmente en el pre-lanzamiento de Visual Studio Tools
para Python previamente incluido con el instalador de Visual Studio y seguirá siendo válida una vez que el buque de herramientas
actualizada.
Nota: La razón por la que estoy mostrando un ejemplo basado en Python pesar de que sólo estará disponible
después de naves RTM es que es la manifestación perfecta de un amplio soporte de idiomas con características de
depuración y refactorizaciones de código.
Cuando haya terminado, abra la carpeta que contiene el proyecto de Python con el Carpeta abierta
mando. A continuación, abrir cualquier archivo de código .py para ver cómo el editor de código proporciona la coloración de sintaxis
esperada. La Figura 48 muestra un ejemplo basado en el archivo tests.py.
Figura 48: Sintaxis Colorization para Python
62
Al empezar a escribir, verá IntelliSense en acción, no sólo la finalización de código. La figura 49 muestra la forma de IntelliSense para
Python muestra elementos con iconos que explican el alcance de un artículo, como palabras clave, funciones y tipos. Recuerde que
IntelliSense está disponible para Python, debido a la carga de trabajo específica de la instalación, de otro modo sólo la finalización de
código estaría disponible.
Figura 49: IntelliSense para Python
Es posible que aparezca un mensaje de advertencia que la realización DB necesita actualizarse. Esto sucede porque IntelliSense
para Python se rellena con una base de datos externa, que es diferente de lo que ocurre con C # y Visual Basic, en el que las API
Roslyn exponer a los miembros disponibles a Visual Studio. Si aparece el mensaje de advertencia, haga clic en el Entornos de
Python hipervínculo en el IntelliSense emergente (véase la Figura 49). Esta acción abrirá la ventana de herramientas Python
entornos, donde se puede ver una lista de entornos e intérpretes disponibles (ver Figura 50). La carga de trabajo de desarrollo de
Python se instala la última versión del intérprete de la oficial de Python Software Foundation página web, en este caso la versión 3.5.
Dependiendo de la máquina, la carga de trabajo se instala la versión de 32 bits o 64 bits. Verá una Refrescar botón cerca del pitón
ambiente clic en él para iniciar la actualización de la base de datos de finalización.
La Figura 50 muestra esta operación en curso. Tenga en cuenta que no todos los entornos disponibles también están instalados
localmente. Por ejemplo, en la figura 50 se puede ver cómo el medio ambiente Anaconda aparece deshabilitado, lo que significa disponible,
pero no se instala. Esto está disponible como un componente individual en el instalador de Visual Studio o se puede instalar por separado.
63
Figura 50: La ventana Python Environments Tool
Hay otros accesos directos en esta ventana, pero están estrictamente relacionadas con las herramientas de Python para Visual Studio-abordarlos
está más allá del alcance de este libro electrónico. Ahora, es el momento de descubrir algunos de los beneficios del editor de Visual Studio
escribiendo un poco de código Python.
La creación de un elemento de inicio
Como sabemos, un gran beneficio que proviene de la instalación de herramientas de soporte que se extienden de una lengua es ser capaz de ejecutar un
programa directamente desde dentro de Visual Studio. Esto es cierto para el lenguaje Python, también. Con el fin de ejecutar el código, Visual Studio 2017
nos necesita para configurar un elemento de inicio, que es el archivo de código que utilizará para iniciar un programa. Si su carpeta ya contiene un
elemento de inicio, ya está. En este ejemplo actual, el proyecto Haikunator es una biblioteca que no contiene un elemento de inicio. Para añadir uno, haga
clic en la carpeta raíz de Explorador de la solución, a continuación, seleccione Añadir > Nuevo archivo. Verá un nuevo archivo en la carpeta. Puede
escribir el nombre que desee, pero para mantener la coherencia en este capítulo, introduzca Startup.py y pulse Enter. En este punto, escriba el código que
se muestra en el Listado de Código 1. Usted recibirá IntelliSense a medida que escribe, y esto hará que su experiencia de codificación verdaderamente
impresionante.
64
Listado de Código 1
de haikunator importar Haikunator haikunator =
Haikunator () name = haikunator.haikunate () print
(nombre)
El código es muy simple: lo que importa la Haikunator tipo que se define en el paquete haikunator y genera un nombre aleatorio invocando la haikunate
método. A continuación, simplemente imprime el nombre en la pantalla. Esto es suficiente para demostrar una serie de características del editor
de código. Cuando se abre el editor de código en un archivo específico, ya sea nueva o existente, este se ajustará automáticamente como el
elemento de inicio. En este caso, Startup.py se establece automáticamente como el elemento de inicio para el programa. Si desea utilizar un
archivo de inicio diferente, simplemente abrirlo o haga clic derecho en su nombre
Explorador de la solución, a continuación, seleccione Establecer como Elemento de inicio.
Ejecución de un programa de
Como lo haría con cualquier otro proyecto de Visual Studio, puede ejecutar un programa pulsando F5 (modo de depuración), Ctrl + F5 (sin
depurar), o haciendo clic comienzo en la barra de herramientas estándar. Cuando se trabaja con carpetas, el botón de inicio muestra el
nombre del elemento de inicio (ver Figura 51).
Figura 51: Botón de Inicio Muestra el nombre del elemento de inicio
Sea cual sea la opción que elija inicio, el programa se ejecutará como se esperaba. En este caso en particular, no es necesario
invocar manualmente el intérprete de Python. Inicio del programa de ejemplo producirá el resultado mostrado en la Figura 52 (el
nombre aleatorio generado variará en su máquina).
sesenta y cinco
Figura 52: Ejecución de un programa de Python desde Visual Studio 2017
Observe que, en relación específica a Python, la carga de trabajo de instalación configura automáticamente Visual Studio 2017 para ejecutar el
intérprete desde el IDE contra el elemento de inicio seleccionado. Para otros idiomas y con otras herramientas, Visual Studio 2017 se debe
configurar manualmente para funcionar compiladores o intérpretes. Vamos a ver esas situaciones más adelante en este capítulo. Por ahora,
echar un vistazo más de cerca a la Figura 52-note como la barra de estado de Visual Studio es de color naranja, lo que significa que está en
modo de depuración. Esto también implica que el nuevo IDE puede utilizar herramientas de depuración externos.
depuración
Visual Studio 2017 puede extender el depurador para admitir idiomas adicionales. cargas de trabajo específicas o herramientas de
terceros pueden instalar componentes de depuración que el IDE puede integrar en su potente experiencia de desarrollo. Para una
mejor comprensión de esto, abra el
haikunator.py presentar en el editor de código. Ir a la última línea de código y colocar un punto de interrupción exactamente como lo haría en C # o
Visual Basic. Asegúrese de que abra la Startup.py archivo para que esto se establece de nuevo como el elemento de inicio, a continuación, ejecutar
el programa. Después de unos segundos, el depurador se interrumpirá la ejecución de la aplicación debido al punto de ruptura. En este punto, usted
será capaz de utilizar las características de depuración de gran alcance que ya conoce, como sugerencias de datos, variables locales y otras
ventanas de depuración. La figura 53 muestra un ejemplo.
66
Figura 53: El depurador de apoyo y la integración para Python
Debemos recordar que las características tales como la depuración y IntelliSense no están disponibles para todos los idiomas
compatibles, sino que están disponibles a través de las cargas de trabajo específicas o herramientas de terceros. Sin embargo, Visual
Studio 2017 ofrece su entorno sólido de idiomas non-.NET, y esto es un gran valor añadido para cualquier desarrollador.
Código de refactorización
Para idiomas específicos, el estudio 2.017 editor de código de Visual también ofrece bombilla y acciones rápidas para proporcionar una
experiencia de edición de código evolucionada. Por ejemplo, en Python se puede seleccionar un bloque de código y extraer un método como
lo haría con C # y Visual Basic refactorizaciones. La figura 54 muestra esto.
67
Figura 54: Código Refactoring para Python
Con soporte para la integración de características tales como IntelliSense, refactorizaciones y depuradores, Visual Studio 2017 hace honor a su
pretensión como la herramienta de desarrollo para cualquier desarrollador en cualquier plataforma.
tareas de personalización
Anteriormente, vimos lo fácil que es ejecutar un programa en Python simplemente presionando F5. Esto es así porque las herramientas de
Python para Visual Studio configurar automáticamente el entorno para ejecutar el intérprete contra el archivo de código fuente seleccionada.
herramientas integradas específicas no existen para todos los idiomas, pero para muchos que todavía pueden automatizar la ejecución de
programas externos, como intérpretes, compiladores, o los comandos de Windows mediante la creación y personalización Tareas.
Consejo: Si está familiarizado con las tareas en código de Visual Studio, usted notará una semejanza muy estrecha con
las tareas en Visual Studio 2017. Tienen diferentes ubicaciones y sintaxis diferente, pero su propósito es exactamente
el mismo.
Una tarea es una operación con una serie de ajustes y se representa con JSON marcado. Los ajustes incluyen el comando a ejecutar y
sus argumentos de línea de comandos. Una explicación será siempre poco, pero por ahora supongamos que usted quiere ser capaz de
compilar o ejecutar un programa Go. Primero necesita un compilador de Go y la configuración adecuada. los Ir Lenguaje de
programación página web tiene todo lo necesario, incluyendo binarios y la documentación. En primer lugar, descargar e instalar el
binarios para Windows . En segundo lugar, crear una carpeta en la que va a escribir un programa Ir simple y configurar el GOPATH variable
de entorno como se explica en el documentación , Que también explica todo lo que necesita saber acerca de la escritura, compilar y
ejecutar código con Go. El instalador configura automáticamente el GOROOT variable de entorno para que pueda ejecutar el
compilador GO.EXE desde cualquier ubicación. En el presente ejemplo, voy a utilizar una carpeta llamada C: \ GoWork. Ahora, todo
lo que necesita para compilar y ejecutar un programa Go está listo.
Nota: Obviamente, los diferentes lenguajes de programación trabajan con diferentes binarios y configuraciones del
sistema, lo que significa que la configuración de tareas requiere los mismos pasos con cualquier idioma, pero con
diferentes configuraciones. En este libro, yo estoy proporcionando un ejemplo basado en ir porque la instalación de
sus binarios es muy fácil, aunque la configuración del sistema requiere algunos pasos manuales.
68
En Visual Studio 2017, abra la carpeta que ha creado (como mi C: \ GoWork). Cuando esté listo, añadir un nuevo archivo llamado HelloWorld.go. A
continuación, introduzca el código mostrado en Listado de Código 2.
paquete principal
importar "FMT"
func principal () {
fmt.Printf ( "Hola mundo desde Visual Studio 2017! \ N" )
Estoy usando un nuevo “Hello World!” Programa en lugar del proyecto Haikunator porque Go requiere que instalar y configurar los
paquetes antes de poder utilizarlas. Debemos compilar e instalar la biblioteca Haikunator, a continuación, proporcionar la
configuración adecuada (lo que nos obliga a estar un poco familiarizado con las reglas Go).
Mientras que proporciona estos datos está fuera del alcance de este libro electrónico, la ir documentación ofrece una buena explicación. Listado
de Código 2 simplemente define un paquete llamado principal e importa una biblioteca de base llamada FMT, luego imprime un simple mensaje
en la pantalla. Ahora en Explorador de la solución, rightclick la Helloworld.go Archivo y seleccione Personalizar la configuración de tareas. Esta
acción creará un nuevo archivo llamado JSON tasks.vs.json, que se encuentra en una carpeta oculta llamada. vs y que reside en el espacio de
trabajo. Este archivo JSON contiene las directivas de Visual Studio necesita saber con el fin de ejecutar una serie de tareas, incluyendo el
lanzamiento del elemento de inicio. La siguiente es una lista de propiedades JSON comunes a todas las tareas:
• nombre de la tarea: Un nombre para la tarea que se mostrará en el Explorador de la solución Menú de contexto.
• se aplica a: Especifica el destino de la tarea actual, por lo general un archivo específico.

• tipo: Representa el tipo de tarea, por lo general de mando.
Debe editar tasks.vs.json y especificar que debe ejecutar el compilador GO.EXE contra el archivo de código fuente de corriente.
Listado de Código 3 muestra cómo lograr esto mediante la adición de la mando
y args propiedades.
69
"versión" : "0.2.1" ,
"Tareas" : [
"nombre de la tarea" : "Ejecutar Hello World" ,
"se aplica a" : "Helloworld.go" ,
"tipo" : "mando" ,
"mando" : "GO.EXE" ,
"args" : [ "correr" , "Helloworld.go" ]}]}
Date cuenta cómo mando especifica el nombre del programa externo que debe ser ejecutado. En este caso, se especifica el nombre de
archivo del compilador sin camino porque una variable de entorno se ha establecido por el instalador. En lugar, args especifica los
argumentos de línea de comandos para el comando en la forma de una matriz JSON. En este caso, el primer argumento es una opción
llamada correr
que indica al compilador para generar y ejecutar un programa, y el segundo argumento es el nombre del archivo que debe compilarse.
Nota: Tasks.vs.json puede contener muchas tareas, como por ejemplo para la construcción de una carpeta completa o limpiar la
acumulación de salida. Para más opciones de configuración, se puede leer
esta entrada del blog Del equipo de C ++ Visual en el que ofrecen más explicaciones sobre varias
configuraciones de tareas, constantes, literales, apoyados y macros.
En este punto, haga clic en el Helloworld.go nombre del archivo en Explorador de la solución, a continuación, seleccione Ejecutar Hello World en
el menú contextual (este es el nombre de la tarea que ha proporcionado antes). Esta acción abrirá el compilador de Go y hará que la salida del
programa visible en la Salida ventana, como se muestra en la Figura 55.
70
Figura 55: Ejecución de un programa Ir a una tarea
Aunque usted no tiene soporte de depuración o una ventana de la consola para la ejecución, que ha sido capaz de ejecutar un programa Go
desde dentro de Visual Studio 2017. Muchas otras posibilidades para la automatización de tareas están disponibles para usted que proporcionan
un mayor control sobre todos los idiomas soportados.
¿Qué hay de nuevo para los proyectos de control de origen y de equipo
Visual Studio 2017 también tiene algo nuevo para la colaboración en equipo. De hecho, ahora se puede utilizar un nuevo cuadro de
diálogo para conectarse a Visual Studio Team Services y Team Foundation Server. Por ejemplo, en Team Explorer, haga clic Gestionar
las conexiones, entonces Conectarse a equipo de proyecto. En este punto, verá un nuevo diálogo de llamada Conectarse a un
proyecto, que muestra todas las cuentas de Visual Studio Team Service y los servidores de TFS que está suscrito (ver Figura 56). De
manera predeterminada, Visual Studio busca repositorios asociados con la cuenta de Microsoft utilizó para iniciar sesión en el IDE, pero
se puede añadir varias cuentas a través de la cuenta desplegable. Al hacer clic Conectar, Visual Studio Team Explorer se abrirá
mostrando un botón etiquetado Mapa de Obtener,
que proporciona un acceso directo para asignar el repositorio remoto a una carpeta local y obtener la última versión del
código fuente del servidor.
71
Figura 56: Conexión a Visual Studio Team Services repositorios
Si hace clic Añadir TFS Server, usted será capaz de añadir y conectarse a instancias TFS de correo locales. La Figura 57 muestra un
ejemplo basado en la información ficticia.
72
Figura 57: Adición de una en locales TFS Instancia
Al igual que con la team Services pestaña, aquí son todavía capaces de cartografiar el repositorio en una carpeta local y obtener la última versión
del código fuente. Todas las otras características relacionadas con la colaboración del equipo, incluyendo Team Explorer, permanecen sin
cambios.
Consejo: También puede activar el diálogo de conexión a través de la Gestionar las conexiones
comando en el Equipo menú.
73
Nota: Visual Studio 2015 Actualización 2 introduce los comandos más Git en Team Explorer y atajos para
repositorios Git en la esquina inferior derecha de la barra de estado. Visual Studio 2017 hereda estas
características, pero no introduce nada nuevo. Si desea obtener más información acerca de estas funciones,
lea las secciones IDE de Visual Studio Team Explorer y de la Visual Studio 2015 Actualización de las notas 2
de liberación .
Visual Studio 2017 introduce mejoras muy importantes y características para soluciones, proyectos y archivos de código. Con Cargar solución
ligera, grandes soluciones se pueden cargar de manera más eficiente y más rápido. El nuevo IDE también admite un conjunto más amplio de los
lenguajes de programación, incluso cuando no hay cargas de trabajo instalados, y el editor de núcleo puede trabajar con las carpetas que
contienen los archivos de código, que proporciona no sólo una representación estructurada, organizada, sino que también ofrece características
básicas tales como la coloración de sintaxis y el código finalización, así como características evolucionadas, como IntelliSense, depuración y
fragmentos de código. Para apoyar estas y otras características nuevas o actualizadas, la arquitectura de Visual Studio 2017 es muy diferente de
las anteriores ediciones, y esto afecta a la extensibilidad, como veremos en el siguiente capítulo.
74
Capítulo 6 Extensiones y extensibilidad
Los cambios en la arquitectura de Visual Studio 2017 tienen un impacto en el modelo de extensibilidad. En este capítulo se
describen las mejoras en la gestión de extensiones y extensión, sino que también proporcionará información para los autores
de extensión que buscan actualizar su Visual Studio 2015 extensiones al modelo Studio 2017 Visual extensibilidad.
¿Qué hay de nuevo con extensiones en Visual Studio 2017
En Capítulo 1 , He descrito el nuevo modelo de instalación en función de las cargas de trabajo y la forma en que ahora
la posibilidad de instalar varias ediciones de Visual Studio 2017 en la misma máquina. Por ejemplo, un desarrollador
que desee instalar una extensión para la edición Enterprise, pero no para la edición de la comunidad, mientras que otro
desarrollador podría tener sólo el editor de núcleo instalado y no hay cargas de trabajo de manera que algunas
extensiones no funcionarían. En consecuencia, las extensiones deben ser lo suficientemente versátil como para caber
en estas situaciones. Con el fin de apoyar a estos escenarios, Microsoft cambió el modelo de extensibilidad mediante la
introducción de la versión 3 del formato de archivo .vsix, que representa a los instaladores de extensión de Visual
Studio. Esto presenta una serie de cambios de última hora que se describirán más adelante en este capítulo. Por
ahora,
Itinerancia Extension Manager
La primera novedad importante con respecto a las extensiones es el Itinerancia Administrador de extensiones. Esta herramienta permite para
sincronizar las extensiones instaladas en cada instalación de Visual Studio tiene en diferentes máquinas. El Director de Roaming de extensión
está incluido en el Las extensiones y actualizaciones diálogo que se habilita a través Herramientas > Extensiones y actualizaciones. La figura
58 muestra lo que la herramienta se parece.
75
Figura 58: Activación de la Extension Manager Roaming
El estado de una extensión está representado por uno de los tres iconos siguientes:
• Una nube blanca significa la extensión está sujeta a itinerante, pero no está instalado localmente.
• Una nube blanca con un símbolo de verificación verde significa la extensión se instala localmente y vaga.
• Un símbolo de verificación verde significa la extensión se instala localmente, pero no vagar.
Se puede controlar la extensión de itinerancia mediante la selección de una extensión y luego haciendo clic Deja de Roaming
(Si vaga) o Comience Roaming ( si sólo está instalado localmente). En Visual Studio 2017, este es uno de los ajustes sincronizados
que permiten, una vez que inicie sesión con su cuenta de Microsoft.
La programación de las operaciones sobre las extensiones
Visual Studio 2017 también introduce una nueva manera de instalar, actualizar y desinstalar extensiones. De hecho, el IDE ahora le
permite programar varias extensiones para la instalación, actualización o eliminación. Estas operaciones se ejecutarán en mayor
cuando se cierra Visual Studio. Con el fin de entender cómo funciona esto, considere la figura 59, en la que se puede ver la Las
extensiones y actualizaciones diálogo. En la figura, se pueden ver dos extensiones marcados con un icono de reloj. Este icono
aparece después de descargar una extensión, y significa que se instalará después de Visual Studio se apaga.
76
Figura 59: Programación de Operaciones para las extensiones
En la esquina inferior derecha, se puede ver la lista de las operaciones programadas agrupados por Programado para su instalación, por
Actualización y programada para la desinstalación. Por ejemplo, la Figura 59 muestra el número 1 al lado de la actualizaciones nodo, que
significa que hay una actualización disponible para una extensión. Al hacer clic en el actualizaciones nodo y haga clic en el Actualizar botón
para cada actualización disponible, la extensión será incluido en la actualización programada Para el grupo. La figura 59 muestra cómo,
en mi máquina, hay una actualización disponible para la extensión GitHub que se instalará cuando Visual Studio se apaga, junto con las
otras extensiones que figuran en el grupo programada para Instalar.
Esto también se aplica a las extensiones que desea eliminar. Puede excluir una extensión de la programación, simplemente haciendo
clic en el x símbolo junto a su nombre. Si está familiarizado con Visual Studio
2015, ustedes pueden recordar cómo las extensiones y actualizaciones ofertas de diálogo botones para reiniciar el IDE con el fin de
completar la instalación o actualización de una o más extensiones. En Visual Studio
2017, ya no tienen este tipo de botones. En su lugar, sólo tiene una opción para cerrar el diálogo. Todas las operaciones se
ejecutarán en mayor cuando el IDE se apaga. Esta es una forma más conveniente de administrar las extensiones que evita
que se mueven su foco lejos del entorno de desarrollo.
77
Novedades de la extensibilidad
Nota: Esta sección está dedicada a la extensión de autoría. Si usted está interesado en este tema, asegúrese de que
ha instalado el Visual Studio carga de trabajo de desarrollo de extensión. Voy a suponer que usted está
familiarizado con la extensión de autoría en las versiones anteriores de Visual Studio, por lo que algunos pasos y
conceptos no se abordará en detalle.
autoría de extensión para Visual Studio 2017 requiere frente a algunos cambios que rompen con las ediciones anteriores por el nuevo
modelo de extensibilidad y la versión 3.0 del formato de archivo .vsix. Rompiendo cambios se deben principalmente a los siguientes
escenarios que Visual Studio 2017 debe ser compatible con:
• Los desarrolladores pueden instalar varias ediciones en la misma máquina, por lo que las extensiones ya no se pueden instalar
en una ubicación centralizada, sino que debe ser instalado en cada edición.
• Los desarrolladores pueden instalar sólo el editor de Visual Studio núcleo sin cargas de trabajo, o sólo un número limitado de cargas de
trabajo. Eso significa que las extensiones deben ser capaces de detectar si se han instalado las cargas de trabajo y componentes que
necesitan para trabajar.
Hay una implicación importante aquí: Visual Studio 2017 sólo puede aceptar extensiones escritos específicamente para esta versión
del IDE e instalados a través de la versión 3.0 de un paquete .vsix. Una extensión escrita para Visual Studio 2015 no puede ser
simplemente actualiza o vuelve a compilar para apuntar Visual Studio 2017. Sin embargo, una extensión escrita para Visual Studio
2017 puede dirigirse a través de Visual Studio 2012. Como autor de extensión, debe ser consciente de estas consideraciones si tiene
extensiones existentes que desee al puerto a Visual Studio 2017.
Crear una extensión en blanco para fines de demostración
Con el fin de describir las nuevas características de la extensión de autoría, se requiere un proyecto de extensibilidad. Ahora puede simplemente
crear un proyecto en blanco, ya que las nuevas características residen en el manifiesto VSIX. Sigue estos pasos:
1. Seleccionar Archivo > Nueva > Proyecto.

2. En el Nuevo proyecto de diálogo, expanda el idioma de su elección (C # o VB), a continuación, seleccione
el Extensibilidad nodo.
3. Seleccione el Proyecto VSIX plantilla, proporcionan un nombre de proyecto diferente si lo desea, y luego
hacer clic DE ACUERDO.
4. Haga clic en el nombre del proyecto en Explorador de la solución, a continuación, seleccione Agregar ítem nuevo.
5. En el Agregar ítem nuevo de diálogo, haga clic en el Extensibilidad nodo.
6. Seleccione una de las plantillas de elementos disponibles, haga clic en DE ACUERDO. Si usted quiere ser coherente
con este libro electrónico, elegir el Ventana de herramientas personalizada modelo.
Cuando todo está listo, haga doble clic en el source.extension.vsixmanifest archivo. Este es el manifiesto de extensión que
contiene toda la información y los metadatos necesarios para construir el paquete .vsix.
78
Especificación de requisitos previos de extensión
En el diseñador de manifiesto, verá un nuevo elemento llamado Requisitos previos ( véase la Figura 60).
Figura 60: El artículo Nuevos Requisitos previos en el diseñador de manifiesto
Este nuevo elemento es muy importante, ya que permite especificar las cargas de trabajo o componentes individuales de su extensión
requiere con el fin de trabajar dentro de Visual Studio 2017. Como se puede ver, un requisito previo llamado Visual Studio editor de núcleo
está disponible de forma predeterminada y se dirige a los actuales y futuros versiones del IDE. Hacer clic Nuevo añadir un nuevo requisito. los Añadir
Nuevo Requisito
diálogo aparecerá, y se puede seleccionar una carga de trabajo o componente en el cuadro combinado, como se muestra en la Figura 61.
79
Figura 61: Selección de un Requisito previo
Una vez seleccionado, usted será capaz de especificar un número de versión para el pre-requisito, como se muestra en la Figura 62.
Figura 62: Especificación del número de versión de un Requisito previo
80
Especificación de una versión es opcional porque Visual Studio 2017 selecciona automáticamente la versión IDE corriente
detectada en el equipo de desarrollo.
Nota: Esta sección ha sido escrita conjuntamente con el candidato de versión de Visual Studio 2017, lo que
significa que el número de versión por defecto podría ser ligeramente diferente cuando Visual Studio alcanza
el hito de RTM.
Después de especificar los requisitos previos necesarios, usted puede construir su paquete .vsix. Cuando se inicia en la máquina
objetivo, el instalador VSIX mostrará la lista de requisitos previos necesarios.
el apoyo y el archivo de instalación personalizada NGEN
El nuevo formato .vsix soporta la herramienta Generador de imágenes nativas Ngen, que permite la creación de imágenes nativas del conjunto
de extensión y los ensamblados de referencia. Esto se puede ajustar mediante el propiedades ventana, como se muestra en la Figura 63.
Figura 63: Ngen y archivo de propiedades en Destino
Las siguientes opciones están disponibles Ngen:
• NGEN: Establece si se utiliza NGEN. Opciones son verdaderas o falsas (por defecto).
• Aplicación Ngen: La aplicación de pasar a Ngen a través del conmutador / ExeConfig.
• NGEN Arquitectura: Especifica la arquitectura entre x86, x64, y todo.
• NGEN Prioridad: Especifica el nivel de prioridad NGEN.
81
En la figura 63, también se puede ver un grupo llamado VSIX, lo que le permite controlar el comportamiento de algunos activos importantes, tales
como el archivo de .pkgdef. Propiedades son fáciles de entender, pero vale la pena destacar cómo se puede especificar un destino de la
instalación diferente a través de la propiedad raíz de instalación. Aquí se puede elegir una carpeta de destino de una lista predefinida, pero a
menos que tenga necesidades muy específicas, por defecto es una buena opción.
Visual Studio 2017 presenta dos nuevas herramientas para el consumo de extensiones de terceros la extensión del administrador de itinerancia,
lo que hace que sea fácil hacer la misma extensión disponible a través de máquinas, y apoyo a las operaciones de programación más
instalación de la extensión, actualización y eliminación. Esto evita la necesidad de cerrar y reiniciar el IDE cada vez. Para los autores de
extensión, Visual Studio 2017 presenta la versión 3.0 del formato de archivo .vsix, lo que requiere la especificación de requisitos previos de
extensión (cargas de trabajo o componentes), y permite controlar el comportamiento de la extensión mediante la creación de imágenes nativas
de las asambleas y mediante el control de la carpeta de destino.
82
Capítulo 7 depuración y pruebas
mejoras
Depuración y código de prueba son dos tareas fundamentales en el ciclo de vida de desarrollo de aplicaciones, y debería ser ninguna
sorpresa que Visual Studio 2017 introduce mejoras importantes para ambos. Estas mejoras hacen depuración y pruebas más rápido
pero todavía eficiente mientras se mantenga su enfoque en el editor activo. Este capítulo describe las nuevas características, pero
también caminar a través de herramientas actualizadas que ya conoce y que, en Visual Studio 2017, llegar a una nueva vida.
La introducción de ejecución para hacer clic
Cuando está depurando, pasando a través de líneas de código es una de las operaciones más comunes. Utilizamos los puntos de interrupción, y
luego utilizar funciones como en Paso a paso, paso encima, o salir con el fin de entender el comportamiento de los bloques de código, variables
locales, y más en general, el flujo de ejecución de aplicaciones. Antes de Visual Studio 2017, tuvimos que introducir puntos de interrupción
temporales para continuar la ejecución de un punto de ruptura a un cierto punto en nuestro código. Visual Studio 2017 hace un paso adelante e
introduce una nueva característica llamada Ejecutar en Clic. Para entender cómo funciona esta característica, considere la figura 64, en la que se
puede ver que un punto de interrupción se ha visto afectada y la aplicación está en modo de interrupción.
Figura 64: La Carrera de clic en el icono
83
Al pasar sobre una línea de código, un glifo verde aparece cerca de la línea, como se muestra en la línea 43 del archivo de código en la
Figura 64. Este glifo representa el botón Ejecutar en Clic. Si hace clic en él, el código se ejecutará a esa línea, sin necesidad de puntos
de interrupción temporales. En realidad, la línea en la ejecución de Click se activará se resalta pero no ejecutado, tal y como sucedería si
un punto de interrupción se establece en esa línea (véase la Figura 65).
Figura 65: Run to click se detiene en una línea de código sin un punto de interrupción
A continuación, puede seguir utilizando el Haga clic en Ejecutar para botón y ejecutar código a un punto específico, evitando de esta manera los puntos
de interrupción temporales.
Consejo: Tenga en cuenta que se ejecutan a Haga clic sólo funciona en modo de interrupción, lo que significa que no está
disponible cuando se ejecuta la aplicación.
ventanas de diagnóstico actualizado
Visual Studio 2015 introdujo el Herramientas diagnosticas ventana, que muestra eventos de aplicación, la memoria y el uso de la CPU, y otra
información de diagnóstico en tiempo de depuración. Esta ventana de herramientas aparece de forma predeterminada cuando se inicia la
depuración de la aplicación. En Visual Studio 2017, la ventana Herramientas de diagnóstico ha sido actualizado con una vista llamada Resumen
( véase la Figura 66).
84
Figura 66: El Nuevo Resumida de las herramientas de diagnóstico
Esta nueva vista contiene un resumen del número de eventos de aplicación (Mostrar Eventos), excepciones, eventos IntelliTrace,
Contribuciones de aplicación (en su caso), y eventos de análisis de la interfaz de usuario para aplicaciones UWP. Proporciona atajos para
tomar instantáneas del montón administrado y para activar o desactivar el perfil de la CPU.
Consejo: Puede activar o desactivar eventos específicos IntelliTrace yendo a Herramientas > Opciones > IntelliTrace >
IntelliTrace Eventos.
85
Nota: Los eventos de análisis de la interfaz de usuario son una característica nueva en plataforma Windows universal que
detecta los problemas de accesibilidad. Ellos serán tratados en Capítulo 8, “Visual Studio 2017 para el desarrollo móvil.”
Esta nueva visión ofrece una perspectiva rápida de lo que está sucediendo en el tiempo de depuración, a continuación, puede utilizar las otras pestañas para
más detalles.
El análisis de excepciones con el ayudante de excepción
El ayudante de excepción es una ventana emergente que aparece cuando una excepción no controlada o arrojados produce en tiempo de
depuración. A través de la ayudante de excepción, Visual Studio muestra detalles sobre la excepción. Las versiones anteriores de Visual Studio
En el Ayudante de excepciones y Excepción herramientas de diálogo, que tuvo diferentes enfoques para la productividad. En Visual Studio 2017,
el ayudante de excepción tiene un aspecto completamente nuevo y mejorado comportamiento. Antes de examinar los nuevos beneficios,
echemos un vistazo a la figura 67, que muestra el Ayudante de excepciones actualizada en acción.
Figura 67: El ayudante Excepción actualizado
86
Vamos a resumir lo que hay de nuevo:
• El ayudante de excepción aparecerá si está depurando administrado o código no administrado.
• Cuando se produce una excepción no controlada, toda la línea de código se pone de relieve. Esto mejora la legibilidad del
código. Un icono de error de excepción le ayudará a entender por qué la ejecución fue interrumpida.
• El ayudante de excepción emergente es más pequeño, no modales, y menos distracción.

• A primera vista, el pop-up muestra sólo el tipo de excepción, el mensaje de error, y si la excepción fue
lanzado o no controlada.
• La ventana emergente muestra inmediatamente cualquier excepción, sin la necesidad de diálogos adicionales interiores.
• En el Ajustes de excepción grupo, puede especificar si el depurador debe romper la ejecución cuando se
produce la excepción, y se puede excluir módulos específicos de romper la ejecución.
• Si hace clic en el Ajustes de excepción abiertas hipervínculo, la información de excepción se mostrará dentro de la Inspección
rápida de diálogo (ver Figura 68). Esto hace que sea fácil para investigar los detalles de la excepción y volver a evaluar una
expresión.
• Puede hacer clic en el Editar Condiciones hipervínculo para especificar cuando la ejecución debe ser roto por la inclusión o
exclusión módulos específicos (véase la Figura 69). Este es el único caso en el que se interactúa con un diálogo modal del
ayudante de excepción.
Figura 68: la configuración de excepción dentro del diálogo Inspección rápida
87
Figura 69: Tratamiento de condiciones de excepción
Con su nuevo aspecto y comportamiento, el ayudante de excepción mejora la productividad al proporcionar toda la información que necesita, mientras
que le permite concentrarse en el código.
Presentación de pruebas unitarias en Vivo
Nota: Esta función sólo está disponible en la edición Enterprise y sólo para C # y Visual Basic, y se asume
que ya tiene conocimientos básicos de las pruebas unitarias. Si necesita alguna orientación, la documentación
de MSDN tiene todo lo necesario para empezar.
Unidad de Pruebas en vivo es una característica nueva y emocionante en Visual Studio 2017. Se permite la ejecución de pruebas unitarias en el
fondo y mostrando sus resultados y la cobertura en el editor de código a medida que escribe. La mejor manera de entender cómo funciona esta
característica es con un ejemplo. Crear una aplicación de consola y considerar Listado de Código 4.
espacio de nombres ConsoleApp1 {
clase Programa
hoyo estatico Principal( cuerda [] Args) {
var HR = nuevo RectangleHelpers ();
doble resultado = rh.CalculateArea (10, 10); }}
88
público clase RectangleHelpers
// Calcular el área de un rectángulo.
público doble CalculateArea ( doble anchura, doble altura) {
regreso Ancho Altura *; }}}
los RectangleHelpers clase proporciona una forma muy sencilla CalculateArea método que devuelve el área de un rectángulo cuando
se administra anchura y altura. La clase se instancia y el método se invoca en el Principal método de la Programa clase. Ahora tiene
que crear algunas pruebas unitarias. Haga clic con el CalculateArea método, entonces seleccionar Crear pruebas unitarias. los Crear
prueba Unidad
de diálogo (ver Figura 70) aparece y le pide que especifique la información básica para un proyecto de prueba. Por defecto, el marco de
pruebas es MSTestv2 y la oferta es crear un nuevo proyecto de prueba. Deje todos los valores predeterminados y haga clic DE ACUERDO. Por
supuesto, puede cambiar la configuración predeterminada si tiene experiencia previa con las pruebas unitarias en Visual Studio. En el
momento de la escritura, los marcos de prueba admitidos son MSTest, xUnit y NUnit.
Figura 70: Creación de un proyecto de prueba
89
Ahora usted tiene una clase de prueba llamada RectangleHelperTests y un método llamado
CalculateAreaTest, ambos disponibles en el archivo RectangleHelpersTests.cs del proyecto de prueba. Están decoradas con el TestClass
y Método de prueba atributos, respectivamente, para instruir a Visual Studio que están dentro de un proyecto de prueba y que van a ser
utilizados por el framework de pruebas adecuado y herramientas. En este punto, es necesario poner en práctica su unidad de prueba.
Listado de Código 5 muestra una aplicación muy sencilla que verifica la igualdad entre los resultados esperados y reales.
espacio de nombres ConsoleApp1.Tests {
[ TestClass ()]
público clase RectangleHelpersTests
[ Método de prueba ()]
vacío público CalculateAreaTest () {
var rectHelpers = nuevo RectangleHelpers ();
doble width = 3;
doble height = 2;
Afirmar .AreEqual (6, rectHelpers.CalculateArea (anchura, altura));
}}}
Ahora vuelve al archivo Program.cs. Seleccionar Prueba > Unidad de Pruebas en vivo > Inicio. Después de unos segundos, se verá
cómo Visual Studio se ejecuta la prueba de la unidad en el fondo, mostrando los resultados en vivo en el editor (ver Figura 71).
90
Figura 71: Unidad de prueba Resultados en vivo en el Editor de código
En lugar de ejecutar las pruebas de unidad con el Explorador de prueba, Visual Studio 2017 es capaz de ejecutar las pruebas en el fondo y, lo
más importante, la cobertura asociada y los resultados basados en el código real, no en las pruebas unitarias.
Nota: Visual Studio 2017 puede asociar vivo de pruebas unitarias para su código sólo si las pruebas unitarias tienen
una referencia a un objeto. En nuestro ejemplo, la prueba de la unidad define una instancia de la RectangleHelpers clase,
y por lo que crea una referencia. A continuación, Visual Studio 2017 asocia el CalculateAreaTest método para la
CalculateArea método basado en esta referencia.
Los iconos que aparecen en el editor de código le ayudarán a entender los resultados de pruebas y la cobertura de código. Más específicamente:
• Un icono verde con un símbolo de verificación significa que una pieza de código ha sido cubierto por una prueba de unidad de paso.
• Un icono azul de una línea horizontal representa el código que no está cubierta por cualquier unidad de pruebas.
• Un rojo x icono representa el código que ha sido cubierto por una prueba de unidad que no pasó.
• Cualquiera de estos iconos con un icono de reloj superpuesto indica código que se está editando.
91
Ahora editar el Assert.AreEqual declaración en el CalculateTestArea método de la siguiente manera para realizar la prueba falte;
Assert.AreEqual (5, rectHelpers.CalculateArea (anchura, altura));
Durante la edición, se puede observar que los iconos muestran un reloj superpuesto. Cuando haya terminado, verá que el editor de código se actualiza
para mostrar el resultado de prueba de unidad (fallido, en este caso), como se muestra en la Figura 72.
Figura 72: El editor de código actualizado con la prueba de la Unidad de Resultados
Consejo: Si se pasa sobre un icono, obtendrá detalles sobre el método de ensayo que se invoca en el
fondo (y sus resultados).
Independientemente de los cambios que realice en su código, en vivo de pruebas unitarias se ejecutará en segundo plano, que muestra el
resultado en el editor de código. Puede controlar pruebas unitarias Vivo con comandos dentro de Prueba > Unidad de Pruebas en Vivo -por
ejemplo, pausa, detener y reiniciar. Estos sólo son visibles cuando la función está activa.
mejoras varias
Además de los principales cambios que se describen en este capítulo, Visual Studio 2017 introduce mejoras varias
que hacen que la experiencia de depuración aún mejor. Estos se resumen brevemente en esta sección.
92
mejoras de accesibilidad
La mayoría de las ventanas de depuración (locales, reloj, Inspección rápida, Autos, pila de llamadas) se han mejorado para facilitar la lectura de los
lectores de pantalla y otras funciones de accesibilidad.
IntelliTrace eventos para .NET Core
IntelliTrace, el depurador histórico en Visual Studio, ahora es compatible con los eventos de rastreo en aplicaciones .NET Core. Más
específicamente, se puede habilitar para realizar un seguimiento IntelliTrace ADO.NET, MVC, y HttpClient eventos. Ir Herramientas > Opciones >
IntelliTrace > eventos IntelliTrace para establecer eventos que desea grabar con .NET Core.
Perfilado actualizaciones herramientas
herramientas de perfilado como el rendimiento de perfiles, el uso de CPU, uso de la GPU, y asistente de rendimiento de ahora se puede unir a un
proceso en ejecución. Una opción para que estos estén disponibles cuando se inicia la herramienta de perfilado deseado. La herramienta de uso de
la CPU también se ha mejorado cuando se trabaja con código externo para proporcionar información más detallada.
Soporte para Chrome con JavaScript
Con ASP.NET, si se depura una aplicación que utiliza Chrome como el navegador, el depurador se ejecutará contra el código JavaScript que
se ejecuta en Chrome.
Depuración y pruebas son tareas muy importantes en el ciclo de vida de desarrollo de aplicaciones, y Visual Studio 2017 introduce nuevos extras
para ambos. Con Run para hacer clic, ya no necesita puntos de interrupción temporales para ejecutar código a un punto específico en modo de
interrupción. La ventana de herramientas de diagnóstico proporciona ahora una pestaña Resumen de atajos que le permiten mantener su enfoque en
el IDE-que proporciona esto junto con una versión actualizada del ayudante de excepción que muestra detalles de la excepción de una manera
simplificada y focalizada. Y con Live pruebas unitarias, puede escribir código prueba y la unidad de ejecución en segundo plano, consiguiendo
resultados de la prueba y la cobertura de código directamente en el editor de código, todos viven a medida que escribe.
93
Capítulo 8 Visual Studio 2017 para móviles
Desarrollo
Permitiendo a los desarrolladores crear aplicaciones para cualquier plataforma y dispositivo es un objetivo principal de Visual Studio 2017.
Esto incluye ciertamente desarrollo de aplicaciones móviles. Con la adquisición de Microsoft de 2016 Xamarin, y con mejoras en la
plataforma Windows y universal a las herramientas para Apache Cordova, Microsoft Visual Studio 2017 hace que el entorno de desarrollo
definitivo para la creación de aplicaciones que se ejecutan en Android, iOS y Windows con bases de código compartido. Este capítulo no
pretende ser una guía para el desarrollo móvil con Visual Studio 2017, sino que se hará hincapié en las novedades de las herramientas
más populares para el desarrollo multiplataforma con el IDE de Microsoft. Los enlaces a la documentación de cada herramienta se
proporcionan en su caso.
Visual Studio 2017 y la plataforma Windows universal
Consejo: Documentación para empezar con la plataforma de Windows universal que está disponible en
developer.microsoft.com/en-us/windows/apps/getstarted .
Nota: la creación de aplicaciones de Windows universal requiere la selección de la carga de trabajo de desarrollo
de Windows Plataforma universal en el instalador de Visual Studio.
La plataforma Windows universal (UWP) ofrece una increíblemente rico conjunto de APIs para la creación de aplicaciones que se ejecutan en
Windows 10 y en equipos tales como ordenadores, tabletas, teléfonos inteligentes, Xbox, HoloLens, e Internet de los objetos (IO) dispositivos. En la
mayoría de los casos, código una vez y su aplicación UWP se ejecutará en todos los dispositivos antes mencionados; en algunos casos, tendrá que
hacer ajustes para los SDK específicos.
En marzo de 2016, Microsoft anunció la actualización de aniversario para Windows 10, una actualización importante entregado en julio de
2016, que añade nuevas características y mejoras en el sistema de explotación e incluirse algunas golosinas para los desarrolladores a
través de la actualización de Windows 10 Aniversario SDK. Este último ya está incluido en Visual Studio 2017 a través de la carga de
trabajo de desarrollo UWP. El SDK contiene herramientas integradas para el desarrollo con Visual Studio 2017 y emuladores que apoyan
el aniversario de actualización. Todavía se puede elegir la versión de destino y la versión mínima para sus aplicaciones UWP al crear un
nuevo proyecto. Por ejemplo, seleccione Archivo > Nueva > Proyecto, a continuación, seleccione el Aplicación en blanco (Universal
Windows) plantilla de proyecto en el universal de windows carpeta de la C # y VB idiomas. Antes de generar la solución, Visual Studio le
pedirá que especifique las versiones objetivo y mínimos con el diálogo que se muestra en la Figura 73.
94
Figura 73: Selección del objetivo y Versiones mínimas para Aplicaciones UWP
En la mayoría de los casos, dejando a la selección por defecto es la mejor opción. Al hacer clic DE ACUERDO, Visual Studio genera una
solución que soporta las versiones de Windows 10 especificados. No elimine el nuevo proyecto de mantenimiento que permite que el nuevo
proyecto para servir como un entorno de prueba para futuros temas. Junto con el soporte para la actualización de aniversario, Visual Studio
2017 incluye las siguientes mejoras para UWP.
Nota: La plataforma Windows Universal también recibe todas las mejoras descritas en Capítulo
4, “mejoras XAML.”
Las actualizaciones de .NET nativo
Como se puede saber, la compilación de una aplicación universal de Windows en modo de lanzamiento consiste en la cadena de herramientas nativo
.NET. Piense en .NET nativo como un compilador que produce directamente una imagen nativa de la aplicación en lugar de generar lenguaje
intermedio (IL) que necesitaría una compilación justo a tiempo. Como consecuencia, la puesta en marcha de una aplicación de Windows universal es
mucho más rápido que una
. NET o una aplicación de Windows Phone. Con Visual Studio 2017, la cadena de herramientas nativo .NET se actualiza con parches de más
de 600 errores, la optimización del rendimiento en tiempo de ejecución, y mejoras generales a toda la herramienta.
Nota: Si alguna vez ha escrito una aplicación UWP, usted sabe que la compilación en modo de lanzamiento requiere mucho
más tiempo que en el modo de depuración porque para lanzamiento, Visual Studio .NET 2017 llama a nativo. Detrás de las
escenas, .NET nativo está generando IL de su código C # o VB, a continuación, la conversión de la IL en C ++ - finalmente
producir binarios nativos. Esto es por qué se tarda tanto tiempo, pero esta es también la razón por aplicaciones universales
son tan eficientes.
95
NuGet paquetes actualizados
aplicaciones de Windows universal se basan en el paquete Microsoft.NETCore.UniversalWindowsPlatform NuGet. La total adaptación de

la actualización de aniversario, .NET Core, y Visual Studio 2017, el paquete NuGet antes mencionado se actualiza a la versión 5.2.2. Esta
versión mayoría aborda problemas reportados por los desarrolladores y aplicaciones existentes se pueden actualizar fácilmente con la
herramienta Administrador de NuGet paquete en Visual Studio 2017.
mejoras XAML para UWP
Visual Studio 2017 introduce algunas mejoras en XAML que se dirigen solamente UWP. Los primeros elementos de las direcciones de mejora
de la interfaz de usuario se crea mediante arrastrar y soltar desde la caja de herramientas. Visual Studio 2017 ahora reduce el número de
etiquetas XAML generados automáticamente, lo que significa que el margen de beneficio resultante es más clara y legible. La segunda mejora
se refiere a la XAML diseñador de Visual Studio 2017 introduce un nuevo botón llamado Dispositivo Configuración de vista previa, que se
puede encontrar en la barra superior del diseñador. Haga doble clic en el MainPage.xaml Archivo para abrir el Diseñador de XAML si no está ya
disponible. El nuevo botón está representado por un icono de engranaje y permite cambios rápidos para el contraste y la configuración de tema.
Al hacer clic en él, el Configuración de vista previa dispositivo Aparece el diálogo (ver Figura 74).
Figura 74: Cambio del contraste y del tema Configuración en tiempo de diseño
Se puede elegir entre una serie de posibles ajustes de contraste y entre los temas de luz y oscuridad. Esto hace que sea fácil ver
cómo la interfaz de usuario de la aplicación se comporta con diferentes configuraciones en tiempo de diseño. La tercera se refiere a
la mejora propiedades ventana. Ahora puede asignar propiedades con ecuaciones matemáticas básicas que serán evaluados de
inmediato, y se le asigna el valor resultante para el control seleccionado en XAML. La figura 75 muestra un ejemplo en el que la Anchura
propiedad de una Botón el control se le asigna la suma de 60 + 40.
96
Figura 75: Ecuaciones-evaluado básicos y asignados a la interfaz de usuario Propiedades Elements'
En este caso, se le asignará el resultado de la evaluación (100) a la Button.Width propiedad y será visible en el código XAML.
Es compatible con sumas, restas, multiplicaciones y divisiones. ¿Por qué es útil esta característica? Piense en el Button.Width con
un valor inicial de 60, a continuación, supongamos que desea ver cómo aparece el botón aumentando la anchura de 40. En
lugar de calcular el nuevo valor en la cabeza, simplemente puede escribir la expresión 60 + 40.
Actualizado Diseñador Manifiesto
Probablemente, la actualización más importante para UWP, desde la perspectiva del IDE, se dirige al diseñador Manifiesto, que habilita
haciendo doble clic en el Package.appxmanifest presentar en Explorador de la solución. Más específicamente, la Activos visuales pestaña
tiene ahora una nueva característica llamada Generador de activos, que puede generar automáticamente todos los activos necesarios a partir
de una imagen única fuente de.
Nota: El Generador Visual Activos en Visual Studio 2017 sólo está disponible para Visual Basic y C #.
Soporte para C ++ y JavaScript está prevista para una versión futura.
Usted sólo tendrá que suministrar un archivo de imagen y haga clic en Generar y el generador de activos creará azulejos, logotipos, iconos y pantallas de
inicio en cualquiera o en todas las escalas para adaptarse a cada tipo de dispositivo de sus objetivos de aplicaciones. La Figura 76 muestra cómo el Activos
visuales pestaña aparece en Visual Studio 2017, una imagen de muestra suministrado como fuente de con.
97
Figura 76: El generador de nuevo activo en Visual Studio 2017
Al hacer clic Generar, Visual Studio genera todos los activos necesarios, como se puede ver por el desplazamiento hacia abajo de la
ventana (ver Figura 77). Todos los archivos de imagen generados se enumeran en
Explorador de la solución. Por defecto, el Activos visuales pestaña muestra todos los activos visuales disponibles, pero también se puede seleccionar una
categoría de activos específica de la lista a la izquierda.
98
Figura 77: Los Activos generado automáticamente
Visual Studio 2017 genera activos, asegurándose de que se adhieran a todas las directrices de diseño sugeridas para Windows
10 aplicaciones, tales como relleno y colores de fondo. Esta característica es muy útil y le ayudará a ahorrar una enorme cantidad
de tiempo porque ya no tendrá que proporcionar activos individuales por separado.
Tip: El logotipo de la insignia (para las notificaciones de la pantalla de bloqueo) y el logotipo Paquete activos deben ser
generados de forma individual mediante la selección de los artículos correspondientes de la lista de activos. Usted todavía
suministrar una única imagen de la fuente y, se haga clic en el Generar botón. Visual Studio generará entonces los activos
necesarios de acuerdo con las directrices de Windows 10. Por ejemplo, el logotipo de la insignia, el generador reducirá
automáticamente los colores según el caso.
99
Herramienta de análisis de la interfaz de usuario
los Herramientas diagnosticas ventana en Visual Studio 2017 introduce una herramienta de análisis especial para aplicaciones UWP llamada Análisis de la
interfaz de usuario. Esta herramienta analiza una aplicación para los problemas de accesibilidad y de rendimiento durante la depuración. Análisis de la interfaz
de usuario no está habilitado de forma predeterminada, lo que significa que la primera vez que se inicia la depuración de una aplicación en la ventana de
herramientas de diagnóstico, debe hacer clic Seleccione Herramientas, a continuación, seleccione el
Análisis de la interfaz de usuario artículo (véase la Figura 78).
Figura 78: Activación de Análisis UI
Una vez activada, la interfaz de usuario Análisis sólo estará disponible la próxima vez que inicie la depuración de la aplicación, lo que significa que
primero debe detener la ejecución y luego reiniciarlo. Con el fin de entender cómo funciona esta característica, vamos a introducir un par de
problemas intencionales. En el marcado XAML del archivo MainPage.xaml, inserte el código que se muestra en el Listado de Código 6 en el interior
del defecto Cuadrícula.
< Vista de la lista > < ListView.ItemsPanel > < ItemsPanelTemplate
> < StackPanel /> </ ItemsPanelTemplate
>
</ ListView.ItemsPanel >
</ Vista de la lista >
Este código tiene dos problemas: en primer lugar, la Vista de la lista No se virtualiza, ya que es el uso de un StackPanel
recipiente en lugar de una ItemsStackPanel, entonces el Vista de la lista puede tener problemas de rendimiento cuando se une a una colección de
objetos. En segundo lugar, su Nombre propiedad no ha sido asignado, lo que significa que no hay posibilidad de interactuar con ella en el código. En
este punto, puede iniciar la depuración presionando
F5, a continuación, mantener un ojo en el Herramientas diagnosticas ventana. En el Resumen pestaña verá dos eventos de análisis de interfaz de
usuario y, si hace clic en el Eventos pestaña, verá la lista completa con los detalles de cada evento (ver Figura 79).
100
Figura 79: La Lista de Eventos de análisis de la interfaz de usuario con detalles
Como se puede ver, la lista de eventos de análisis de la interfaz de usuario muestra información detallada para cada evento. Si hace doble clic en
un evento, se le redirige a la línea de código XAML que causó el problema. También puede hacer clic en el Más información sobre este tema hipervínculo
para abrir la documentación de un problema, como se muestra en la Figura 80.
101
Figura 80: La documentación a un problema de Análisis de la interfaz de usuario
La documentación también ofrece una página llamada visión general Análisis de aplicaciones que contiene la lista completa de los problemas de la
herramienta de análisis de la interfaz de usuario puede detectar. La herramienta de análisis de la interfaz de usuario es una adición muy útil, ya que permite
descubrir un gran número de problemas potenciales antes de enviar la aplicación a la tienda de Windows para su aprobación y publicación.
desarrollo multiplataforma con Apache Cordova
Nota: la creación de aplicaciones con Apache Cordova es necesario seleccionar el desarrollo móvil con JavaScript
carga de trabajo en el instalador de Visual Studio. Además, se requiere que el navegador Chrome para las nuevas
características tales como Córdoba Simular.
Apache Cordova es una plataforma de desarrollo que nos permite crear aplicaciones multiplataforma para Android, iOS y Windows
utilizando HTML y JavaScript. Visual Studio 2017, al igual que su predecesor, incluye la Herramientas para Apache Cordova ( TACO)
de modo que usted puede utilizar su potente IDE favorito para escribir, depurar y publicar aplicaciones. También, VS 2017 soportes Iónico
, Un marco de JavaScript populares front-end que funciona con Córdoba. Hay una serie de cambios y mejoras en TACO para Visual
Studio 2017 que mejoran el rendimiento y la productividad. Estas nuevas incorporaciones se demostrará mediante la aplicación de
ejemplo WeatherApp incluido en los ejemplos oficiales de Microsoft para Córdoba. Puede descargar estos de GitHub como un
archivo .zip. los Tiempo aplicación carpeta contiene la solución puede abrir en Visual Studio 2017. Por supuesto, también se puede
utilizar cualquier otro proyecto de Córdoba.
102
Consejo: Al abrir cualquier solución Cordova construidas con versiones anteriores de Visual Studio, VS 2017 tiene que realizar
una actualización de una sola vez. Se le pedirá que vuelva a cargar la solución después de que el proceso de actualización.
Las versiones compatibles y plataformas
En Visual Studio 2017, Herramientas para Apache Cordova ya no son compatibles con Windows 8.1. proyectos existentes deben
actualizarse para apuntar de Windows 10. Esta versión añade soporte para iOS 10 y Xcode 8 en la parte de desarrollo de iOS. Por
último, la versión mínima admitida para Córdoba es
6.0.0. En el momento de escribir esto, Visual Studio 2017 se envía con Cordova 6.1.3. proyectos existentes construidas con versiones anteriores
necesitarán una actualización de una sola vez cuando se abre la solución.
En el navegador de simulación con Córdoba Simular
Si ya has probado Córdoba, se puede saber que ofrece una serie de plugins que pueden ser considerados como bibliotecas que proporcionan
API para acceder a las capacidades del dispositivo, tales como GPS, sensores, estado de la batería compartidos, y así sucesivamente. Visual
Studio 2017 introduce una nueva característica llamada Simular Cordova que le permite simular y controlar el comportamiento de los plugins en
aplicaciones de Android mediante la simulación del entorno de Android en el navegador Chrome sin necesidad de instalar emuladores o el uso
de dispositivos físicos. Como consecuencia de ello, Visual Studio 2017 ahora puede depurar el código JavaScript se ejecuta en Chrome.
Cuando se pulsa F5, Visual Studio 2017 lanza una instancia de Chrome, se une el depurador, y muestra una ventana nueva herramienta
llamada Cordova Simular. La figura 81 muestra un ejemplo basado en una aplicación que utiliza el plugin Geolocalización.
103
Figura 81: Control de Plugins con Cordova Simulate
Simular la ventana Córdoba no sólo le permite controlar la simulación Android en el navegador (ver el Dispositivo grupo), sino que
también le permite administrar los plugins su aplicación utiliza una interfaz de usuario conveniente. Además, se pueden simular
acciones específicas mediante el uso de la Evento fuego en el botón Eventos grupo. Por ejemplo, se puede simular presionando el
botón de hardware nuevo. En la figura 81, se puede ver cómo Cordova Simular permite controlar el plugin Geolocalización
cambiando la posición en el mapa, la simulación de navegación. Esta ventana de herramientas trabaja con muchos otros plugins-por
ejemplo, se puede controlar el estado de la batería o simular sensores tales como la brújula. Para cada plugin, Córdoba Simular
mostrará un grupo específico de propiedades que usted será capaz de cambiar para simular diferentes situaciones.
104
mensaje de coloreado
herramientas Cordova producen mensajes de salida muy detallados, ya menudo es difícil distinguir entre los mensajes importantes,
errores y mensajes de compilación. Debido a que este último puede terminar menudo ignorado, Visual Studio 2017 presenta la
coloración mensaje para los mensajes relevantes que ahora aparecen en azul. La figura 82 muestra un ejemplo basado en la salida de
la acumulación de la muestra WeatherApp.
Figura 82: Mensaje Colorización en Herramientas para Apache Cordova
En subproducto adquisición de herramientas de desarrollo
En Visual Studio 2017, seleccionando el desarrollo móvil con JavaScript carga de trabajo no incluye automáticamente construir herramientas
para Android y Windows, que ahora son opcionales. Esto tiene sentido por dos razones: la instalación del producto es más rápido, y ahora
usted tiene la opción de instalar las herramientas que realmente necesita de acuerdo a cómo continúa el desarrollo. Aunque aún puede
seleccionar las herramientas de construcción como componentes individuales en el instalador de Visual Studio, también puede tomar ventaja
de una nueva característica llamada En subproducto de adquisición. En el desplegable cerca de la comienzo
botón en la barra de herramientas, encontrará una nueva opción llamada Instalar herramientas de construcción refiriéndose a la plataforma
actual. La figura 83 muestra un ejemplo basado en Android.
Figura 83: Instalación de las herramientas necesarias en tiempo de compilación
Esta opción le permite instalar herramientas específicas generar solamente cuando y si usted los necesita.
105
Consejo: En subproducto adquisición no es específico de Córdoba. De hecho, el IDE puede sugerir general SDK y
herramientas basadas en lenguajes y plataformas que se está trabajando.
desarrollo multiplataforma con Xamarin
Nota: las aplicaciones de construcción con Xamarin es necesario seleccionar el desarrollo móvil con C # y .NET carga de
trabajo en el instalador de Visual Studio. Tenga en cuenta que el desarrollo Xamarin no está disponible para Visual Basic.
Xamarin es el nombre tanto de una empresa y una plataforma de desarrollo muy popular que permite construir iOS nativas, aplicaciones
Android y Windows a través de la escritura y el intercambio de código C #. Microsoft adquirió recientemente Xamarin y está realizando
importantes inversiones con el fin de aumentar la productividad con las herramientas Xamarin para Visual Studio. Al igual que con otras
plataformas, mi objetivo aquí no es para describir lo que puede hacer con Xamarin. En su lugar, se encuentra una explicación detallada de lo
que es nuevo con herramientas Xamarin en Visual Studio 2017. Si usted necesita un lugar para empezar, se puede visitar el portal oficial de
desarrollador , Que incluye todos los recursos que necesita tanto para Visual Studio y Studio Xamarin. La primera actualización importante es
que Visual Studio 2017 es compatible con Xamarin 4.3, que mejora significativamente la experiencia de edición de XAML en Xamarin.Forms y
presenta las características que se detallan en las secciones que siguen.
Tip: Las características descritas en esta sección son ofrecidos por la versión 4.3 de las herramientas Xamarin para Visual
Studio, y ellos no son exclusivos de Visual Studio 2017. Esto significa que también estarán disponibles para las versiones
anteriores (como Visual Studio 2015 Actualización 3 y Visual Studio 2013 actualización 2) si actualiza las herramientas
Xamarin. En el momento de la escritura, Xamarin 4.3 está disponible como una versión preliminar a través del actualizador
de canal alfa.
corrección automática de dependencias que faltan Android
Cuando se crea un proyecto Xamarin, algunos componentes requeridos por la plataforma Android podrían no ser detectados. Si
esto sucede, el Lista de errores ventana muestra un mensaje de error que describe los componentes que faltan (típicamente
dependencias JavaScript). En Visual Studio 2015, se le requirió para descargar estos componentes y extraerlos manualmente en
los lugares adecuados. En Visual Studio 2017, la Lista de errores ventana ofrece para descargar e instalar los componentes que
faltan haciendo doble clic en el mensaje de error. En este punto, el IDE descargar e instalar los componentes necesarios en la
forma apropiada. Tenga en cuenta que esto puede tardar unos minutos.
106
Cambios a las plantillas de proyecto
Xamarin 4.3 trae plantillas de proyecto actualizado para Visual Studio 2017. Se puede ver fácilmente esta nueva característica cuando se
selecciona Archivo > Nuevo proyecto. En el Nuevo proyecto diálogo, seleccione Visual C # > Entre plataformas. Como se puede ver en la Figura
84, el Nuevo proyecto de diálogo muestra ahora sólo tres plantillas.
Figura 84: Actualización plantillas de proyecto para Xamarin
Las plantillas Biblioteca de clases y la interfaz de usuario de la aplicación de prueba se toman de las versiones anteriores, mientras que la plantilla de la
Cruz plataforma de aplicaciones es una nueva adición. Si hace doble clic en esta plantilla, se accede a la
New Cross plataforma de aplicaciones de diálogo (ver Figura 85).
107
Figura 85: El Nuevo Diálogo para la creación de proyectos Xamarin
Aquí tienes tres plantillas:
• Detalle Maestro, que genera una interfaz de usuario maestro-detalle, ya sea con XAML (Xamarin.Forms) o la interfaz de usuario
nativa. Se basa en proyectos compartidos y está listo para ser alojado en Microsoft Azure.
• Aplicación en blanco, lo que permite la generación de un proyecto en blanco, ya sea basado en Xamarin.Forms o APIs nativas. Se
puede elegir entre una biblioteca portátil de clase (PCL) y proyectos compartidos de compartir su código C # a través de
plataformas.
• App Blank (XAML). Esta es la plantilla de proyecto que desea utilizar para el desarrollo Xamarin.Forms usando
XAML para la interfaz de usuario (ver Figura 86). Se puede elegir entre PCL y proyectos compartidos, pero en la
mayoría de los casos va a utilizar la opción de PCL.
Figura 86: Creación de un proyecto basado en Xamarin.Forms y XAML
108
Nota: Microsoft ha invertido mucho en las bibliotecas estándar de .NET, que comparten las mismas API a través de
una serie de plataformas. No es ningún secreto que Xamarin debería proporcionar apoyo totalmente integrado para
.NET Norma en el futuro, por lo que tener en cuenta que el apoyo PCL podría ser reemplazado por .NET estándar en
el futuro. Esta entrada en el blog de Xamarin proporciona más información sobre este tema.
Una vez que haya hecho su elección, haga clic Aceptar y esperar a que Visual Studio 2017 para generar su solución. Además de
las plantillas de plataforma cruzada, Xamarin 4.3 introduce nuevas plantillas de proyecto para el desarrollo de iOS nativo que se
puede encontrar en el iOS y TVOS nodos de la Nuevo proyecto de diálogo, en Visual C #. Hay nuevas plantillas para la Vigilancia de
Apple, Apple TV, iOS y extensiones.
editor de .Plist unificado para iOS
Nota: En esta sección se asume que está un poco familiarizado con el desarrollo de iOS con Xamarin.
En el desarrollo de iOS, que proporciona metadatos de aplicaciones, activos, capacidades y requisitos con los archivos plist como info.plist y
entitlements.plist. En Visual Studio, la mayoría de estos ajustes se pueden proporcionar a través del proyecto propiedades ventana, a
continuación, el IDE agrupar la información especificada en los archivos plist adecuados. Además de propiedades ventana, las herramientas
para Visual Studio Xamarin siempre han ofrecido, editores específicos incorporados para archivos plist que permiten ajustes de sintonización
fina con una interfaz de usuario conveniente. Xamarin 4.3 integra un nuevo editor jerárquica unificada que proporciona una mejor
organización de toda la información y permite trabajar con todos los archivos plist en un solo lugar. Asumiendo que tiene ya sea un
Xamarin.Forms o un proyecto Xamarin.iOS abierto en Visual Studio 2017, haga doble clic en el info.plist presentar en Explorador de la
solución para llamar al nuevo editor. La figura 87 muestra cómo aparecerá.
109
Figura 87: El editor de Nueva .Plist para iOS 4.3 en Xamarin
Como se puede ver, el nuevo editor proporciona una visión unificada de configuración de la aplicación y permite hacer cambios rápidamente. Usted
puede agregar fácilmente una configuración personalizada haciendo clic en el icono + en la parte inferior de cada grupo. También puede filtrar la
lista usando el menú desplegable en la parte superior del filtro opciones son iOS InfoPList ( vista completa), iOS Derechos ( Sólo los derechos de
información), y Ajustes iOS Bundle ( sólo información relacionada con paquete de firma). Tenga en cuenta que este editor funciona con cualquier
archivo .Plist, por lo que si se hace doble clic entitlements.plist en Explorador de la solución, obtendrá el mismo editor, pero la vista se limitarán a
los derechos. Si desea cambiar la vista, basta con cambiar el elemento seleccionado en la lista desplegable.
110
desarrollo móvil es crucial para las estrategias de Microsoft y Visual Studio 2017 introduce importantes mejoras en la
experiencia de desarrollo para cualquier plataforma soportada. Para la plataforma Windows universal, tiene un compilador
rápido .NET nativo, paquetes NuGet actualizados, mejor tiempo de diseño y herramientas de diagnóstico, y un diseñador de
manifiesto que genera automáticamente actualizado activos desde un único archivo de imagen. En cuanto a las herramientas
para Apache Cordova (TACO), Visual Studio 2017 permite simular el entorno de Android en el navegador Chrome, que es útil
para depurar aplicaciones que utilizan plugins. El IDE también proporciona mensaje de coloración y la adquisición en el
producto para que pueda instalar las herramientas necesarias sólo cuando y si los necesita. Para Xamarin, se obtiene
plantillas de proyecto actualizados y una experiencia de edición de XAML mejorada, un nuevo editor para.
111
Capítulo 9 Visual Studio 2017 por Cloud y
Desarrollo web
el desarrollo de plataforma cruzada no es sólo el desarrollo móvil. Microsoft ha estado invirtiendo fuertemente en herramientas que los
desarrolladores pueden aprovechar para escribir aplicaciones que se ejecutan en Windows, Mac OS, Linux y sus distribuciones más populares
de construcción. El resultado de estas inversiones es
. NET Core, el marco multiplataforma que le permite construir aplicaciones que se ejecutan en múltiples sistemas que utilizan C #. Las
aplicaciones web se escriben en .NET Core necesitan una infraestructura robusta y Microsoft Azure es el compañero perfecto en la nube.
Cuando se trata de desplegar aplicaciones .NET Core a Azure, muchos desarrolladores deciden adoptar contenedores acoplables. Visual
Studio 2017 tiene soporte integrado para todas estas tecnologías y, una vez más, demuestra ser el entorno perfecto para escribir
aplicaciones que se ejecutan en cualquier plataforma y dispositivo. En este capítulo se proporciona una descripción de alto nivel de lo que
hay de nuevo en el utillaje para la nube y desarrollo web en Visual Studio 2017, y obtendrá enlaces a la documentación oficial para su
posterior estudio.
Nota: En este capítulo se supone que está familiarizado con los conceptos básicos y la terminología Azure. De hecho,
usted encontrará las menciones de los grupos de recursos, planes de servicios de aplicaciones, registros de contenedores
Azure, y otros términos. Si no está familiarizado con Azure, o si algo no está claro, la documentación oficial ayudará.
La creación de aplicaciones multiplataforma con .NET 1.1 Core
Nota: En esta sección se requiere la instalación de la carga de trabajo multi-plataforma de desarrollo .NET Core.
los .NET Core es un código abierto, multiplataforma, tiempo de ejecución modular que se ejecuta en Linux, Mac OS y Windows. Con .NET
Core, puede escribir aplicaciones que se ejecutan en múltiples sistemas operativos y plataformas mediante el uso de sus conocimientos
actuales de C #. naves .NET núcleo con una interfaz de línea de comandos (CLI) y expone un rico conjunto de APIs que se comparten a
través de sistemas operativos y, sucintamente, que le permite desplegar una aplicación mientras incluyendo sólo las bibliotecas de la
aplicación efectiva necesita además de un componente CLR denominado Core. Este último puede ser considerado como un portátil de
Common Language Runtime, y permite que una aplicación se ejecute. Discutir .NET Core en detalle requeriría un libro entero, por lo que este
capítulo se centrará en nuevas herramientas en Visual Studio 2017 que es compatible con la versión 1.1 de las Directrices. Visual Studio 2017
proporciona un nuevo nodo llamado. Core NET en el Nuevo proyecto de diálogo, en Visual C #, como se muestra en la Figura 88.
112
Figura 88: Disponible plantillas de proyecto para .NET Core
Dos plantillas de proyecto (Proyecto de Prueba Unidad de Proyecto de Prueba y xUnit) están relacionados con las pruebas unitarias. Con la
plantilla Aplicación de consola (.NET Core), se puede escribir una aplicación de consola que se extiende desde la línea de comandos en
Linux, Mac OS X y Windows. Con la plantilla de aplicación Web ASP.NET Core (Core NET), puede crear una aplicación web multiplataforma
C # basado en el patrón MVC. La plantilla de biblioteca de clases (.NET Standard) le permite crear una biblioteca que se puede utilizar en
todos los tiempos de ejecución de .NET, incluyendo .NET Core, Mono y .NET Framework.
Consejo: La especificación .NET biblioteca estándar, actualmente en la versión 1.6, está creciendo rápidamente, y
será mucho más importante en las próximas versiones. Si usted bibliotecas de autor, le recomiendo que se tiene en
cuenta bibliotecas .NET estándar en lugar de bibliotecas de clases portátiles. La información detallada y
explicaciones sobre .NET estándar se pueden encontrar en el documentación oficial y en este entrada en el blog desde
el
. Equipo NET de Microsoft.
Por ahora, seleccione la Aplicación Web ASP.NET Core plantilla, dar un nombre al proyecto, a continuación, haga clic DE ACUERDO. En
este punto, usted será capaz de especificar qué tipo de aplicación que desea crear en el nuevo ASP.NET Web Application Core (Core
.NET) de diálogo, como se representa en la Figura 89.
113
Figura 89: Creación de una nueva aplicación Web ASP.NET Core
Como se puede ver, se puede decidir crear una aplicación vacía, un servicio Web API multiplataforma, o una aplicación web
multiplataforma MVC. Selecciona el Aplicación web por coherencia con los siguientes ejemplos.
Con ambos API web y aplicaciones web MVC, también tienen la oportunidad de suministrar el tipo de autenticación de la aplicación debe ofrecer.
El valor predeterminado es sin autenticación, así que haga clic Cambio de autenticación, a continuación, seleccione Las cuentas de usuario
individuales. Por ahora, desactivar la Habilitar el contenedor de soporte (estibador) en el diálogo, y, por último, haga clic DE ACUERDO. el
apoyo del estibador se discutirá más adelante en este capítulo. Como era de esperar de una aplicación MVC, en Explorador de la solución se
puede ver las carpetas que contienen los controladores de C #, los modelos, los archivos de inicio, y servicios necesarios para gestionar el
registro y credenciales (ver Figura 90).
. Las aplicaciones internas NET pueden acceder a bases de datos SQL utilizando una versión multiplataforma del marco de la entidad
denominada Entidad Marco de base. Esto se demuestra por la disponibilidad de la subcarpeta Data \ migraciones, que contiene varios de
los llamados Código primeras migraciones .
114
Figura 90: La estructura de una aplicación Web ASP.NET Core
Nota: Hay un cambio importante importante entre .NET Core 1.0 y 1.1. Con
1.1, Microsoft introduce soporte para .NET MSBuild subyacente, que significa que ahora tienen una solución .sln
archivo y un proyecto .csproj. En la versión anterior, no había ningún archivo de solución y proyecto de
información estaba dentro project.json. Estudio visual
2017, le ayudará a migrar proyectos más antiguos a la versión más reciente, sin embargo.
Detrás de las escenas, Visual Studio 2017 simplemente invoca la interfaz de línea de comandos .NET Core y lanza el siguiente
comando que los andamios de una nueva aplicación Web ASP.NET Core:
> dotnet nueva web -t
dónde - t significa el tipo de aplicación.
115
A continuación, puede añadir su propio modelo de datos, controladores y vistas exactamente como lo haría en una aplicación ASP.NET MVC
construida en .NET Framework completo. Para tener una mejor idea de lo que Visual Studio .NET 2017 genera con Core, sólo tiene que
pulsar F5. Después de unos segundos, verá la aplicación web que se ejecuta en el navegador, como se muestra en la Figura 91.
Todas las poderosas herramientas de depuración en Visual Studio 2017 que ya conoce, estará a su disposición. La aplicación cuenta con un
servicio de autenticación integrado, lo que significa que los usuarios pueden registrarse de forma rápida y acceda a acceder a la información
asegurado dentro de los controladores. Lo más importante, la aplicación web que tiene se puede ejecutar en Mac OS X, Linux y Windows.
Figura 91: una aplicación web compatible con varias plataformas ASP.NET núcleo funcionando en el navegador
No cierre la solución, ya que se usó en la siguiente sección con estibador. Aquí están algunas más consideraciones sobre
.NET Core 1.1 en Visual Studio 2017:
• NuGet referencia el paquete se incluyen ahora en el archivo del proyecto .csproj. Esto hace que sea más fácil para consolidar todos
los paquetes en un solo archivo.
• La herramienta Publicar Web se ha movido de PowerShell para MSBuild.
• . Core NET 1.1 admite referencias estándar, lo que significa que puede agregar referencias a bibliotecas del núcleo non-.NET.
Esto hace que sea más fácil para los proyectos .NET Core para interoperar con proyectos Xamarin.
• Visual Studio 2017 compatible con la entrega continua de envases acoplables directamente desde dentro de la IDE.
116
La siguiente es una lista de recursos útiles para el estudio adicional:
• . Core NET página de inicio .

• Tutorial: Primeros pasos con ASP.NET MVC Core y Visual Studio .
• Entity Framework Core documentación .
• . Core NET herramientas de la interfaz de línea de comandos .
Visual Studio 2017 también permite empaquetar rápidamente una aplicación Web ASP.NET Core en un recipiente acoplable, como
se verá en la siguiente sección.
La introducción de herramientas para contenedores de Docker
Nota: En esta sección se requiere la instalación de la cruz-plataforma .NET Core carga de trabajo de
desarrollo.
Los contenedores pueden ser consideradas unidades de despliegue, y que le permiten empaquetar una aplicación, sus
dependencias, y su configuración del entorno en una imagen que finalmente se implementa en un sistema operativo anfitrión
típicamente Linux o Windows. El mayor beneficio de los contenedores es que aislar las aplicaciones en un sistema operativo común
(Linux o Windows) y son más ligeras que las máquinas virtuales, porque una máquina virtual tiene un sistema operativo anfitrión,
uno o más sistemas operativos invitados, y, por tanto, una gran parte más compleja infraestructura.
En su lugar, utilizan contenedores esencialmente el mismo sistema operativo, compartida, pero se aíslan aplicaciones unas de otras. En el
mundo de los contenedores, Estibador es la plataforma más popular para empaquetar, desplegar y alojar aplicaciones en contenedores, y
se está convirtiendo rápidamente en el estándar. Acoplable puede trabajar en la nube y en las instalaciones, y ha sido adoptado por
muchos proveedores, incluyendo Microsoft y la plataforma Azure. Debido a la creciente importancia y el poder de estibador, Visual Studio
2017 se ha añadido soporte para los contenedores con las herramientas acoplables para Visual Studio, que permiten a los desarrolladores
fácilmente a empaquetar e implementar aplicaciones en contenedores. Esta sección no puede explicar acoplable con todo detalle, pero
demostrará cómo aprovechar las herramientas integradas acoplables para el desarrollo y la depuración. Antes de ver cómo Visual Studio
2017 es compatible de forma nativa del estibador, primero es necesario configurar el entorno de desarrollo.
Consejo: Microsoft ha publicado recientemente un libro electrónico gratuito llamado Contenedores estibador del ciclo de vida
de aplicaciones con herramientas de Microsoft y Plataforma . Este es un muy buen punto de partida si no está familiarizado con
estibador y desea aprender a utilizar con herramientas de Microsoft.
Configuración del entorno de desarrollo
En este capítulo se explicará cómo empaquetar una aplicación .NET Core en un recipiente estibador, y cómo publicar el
contenedor de Microsoft Azure. Antes de continuar, es necesario configurar tanto acoplable y Azure.
117
Nota: La publicación de un contenedor acoplable a Azure es un paso opcional, por lo que puede omitir la creación de un
espacio de trabajo Azure y la sección titulada “Ejecución de un recipiente acoplable sobre el Azure” si no está interesado en
acoplable sobre el Azure. Sin embargo, si usted está interesado, por lo que necesita una suscripción activa Azure. Si usted
no tiene uno, puede solicitar una prueba gratuita en azure.microsoft.com/en-us/free .
Instalación y configuración de Docker
La primera orden del día es la descarga y la instalación Cargador de muelle para Windows para la depuración local. Cuando la instalación se haya
completado, aparecerá el icono del estibador en la barra de la bandeja de Windows. Haga clic en el icono, a continuación, seleccione Ajustes. Cargador de
muelle que tiene que especificar una unidad que proporcionará el sistema operativo compartido para contenedores, así que haga clic unidades
compartidas y seleccione el do
manejar. La figura 92 muestra esto.
Figura 92: Configuración de las unidades compartidas para Docker
Cuando esté listo, haga clic Aplicar y cerrar el diálogo.
Configuración de recursos Azure
Como se verá en breve, Visual Studio 2017 permite publicar rápida y fácilmente una aplicación en contenedores a un sistema
Linux en Microsoft Azure. Con el fin de lograr esto, el IDE se necesita para abastecer el ID de suscripción Azure y algunas
instancias de servicio en la nube. Puedes ver Figura 96 como una referencia. Más específicamente, Visual Studio necesita la
siguiente información:
• Web App Nombre: Representa el nombre del subdominio en el URL de la aplicación.

• Suscripción: La suscripción Azure objetivo.
• Grupo de recursos: Un recipiente que contiene recursos relacionados con una solución Azure. Esto incluye servidores
SQL, aplicaciones web, servicios de telefonía móvil, y mucho más.
118
• Plan de Servicio de aplicación: Una colección de recursos físicos necesarios para albergar una aplicación.
• Registro de envase: Un nuevo recurso que permite el alojamiento y la gestión de contenedores acoplables.
El IDE le permite seleccionar los recursos existentes y crear otros nuevos. Sin embargo, si desea crear nuevos recursos de Visual
Studio, hay un problema-para los nuevos grupos de recursos que no permite para especificar la región Azure. Actualmente, estibador
en Azure es un servicio de vista previa y sólo la región occidental de los EE.UU. apoya alojamiento contenedores de Docker en Linux.
Además, los recipientes de publicación de Azure requiere un plan de servicio de aplicación y un registro de contenedores que deben
estar ubicados en los EE.UU. occidental y se asocia con un grupo de recursos específicos. Por estas razones, y hasta regiones
adicionales permiten acoger contenedores Docker, recomiendo que configure los recursos necesarios en el Portal Azure en lugar de
con Visual Studio. Al iniciar sesión en el Portal, permitirá a los servicios en el siguiente orden (hipervínculos apuntan a la
documentación):
1. Crear una grupo de recursos situado en los EE.UU. occidental Una vez creado, será visible en
la lista de grupos de recursos. Haga clic en él para ver sus detalles.
2. Mientras que en los detalles del nuevo grupo de recursos, crear un nuevo plan de servicio de aplicaciones situado en
los EE.UU. Occidental
3. Volver a los detalles del grupo de recursos y añadir un nuevo basado en Linux registro de contenedores
situado en los EE.UU. occidental una cuenta de almacenamiento situada en la misma región y asociado con el
registro de contenedores se creará automáticamente.
Ahora tiene todo lo necesario para implementar la aplicación empaquetada en un envase acoplable alojado en Azure.
Nota: Asegúrese de que elimina todos sus recursos Azure cuando ya no los necesita, por ejemplo, al
final de sus experimentos y pruebas. Esto evita el riesgo de cargos inesperados en su tarjeta de
crédito.
Activación del estibador en proyectos .NET
En el momento de la escritura, las herramientas acoplables de apoyo Estudio aplicaciones de Visual .NET Core (incluyendo las aplicaciones de
consola) y las aplicaciones ASP.NET clásicos. Para habilitar el soporte acoplable en un proyecto, tiene tres opciones:
• En el caso de nuevas aplicaciones web ASP.NET Core, se puede seleccionar el Habilitar el contenedor de soporte (estibador) bandera
en el Aplicación Web ASP.NET nuevo Core de diálogo, como se puede ver en Figura 89 .
• Seleccionar Proyecto > Soporte Solución ventana acoplable ( o Apoyo a Proyectos ventana acoplable si sólo se necesita para permitir
acoplable a nivel de proyecto).
• Haga clic en el nombre del proyecto en Explorador de la solución y seleccione Añadir > Soporte Solución Docker ( o Acoplable
Proyecto de Apoyo).
Por ejemplo, puede activar fácilmente acoplable apoyo para la aplicación Web ASP.NET Core creado en la sección anterior con Proyecto
> Cargador de muelle de apoyo al proyecto. Esto se añade a los archivos que acoplable necesita para configurar un nuevo contenedor
(y que realmente no necesita cambiar):
119
• Dockerfile: Esto especifica la imagen y la salida de la aplicación. Para ASP.NET Core, la imagen se llama
aspnetcore Microsoft / y ya incluye todas las imágenes nativas de los paquetes NuGet necesarias.
• cargador de muelle-compose.yml: Este archivo define la colección de imágenes para construir y ejecutar dentro del contenedor.
• cargador de muelle-compose.override.yml: Este archivo define el entorno para la aplicación (en este caso ASPNETCORE_ENVIRONMENT)
y el puerto (80) que se expone y se asigna a un puerto asignado dinámicamente por el servidor web de desarrollo
(localhost). El número de puerto se determina por el anfitrión acoplable y se puede consultar mediante scripts acoplables.
• cargador de muelle-compose.dev.debug.yml: Este archivo contiene la configuración adicional cuando la configuración de generación se
establece en Depurar. Esto es usado por las herramientas de desarrollo de Visual Studio.
• cargador de muelle-compose.dev.release.yml: Este archivo contiene la configuración para optimizar la imagen de producción para la
configuración de lanzamiento.
En la barra de herramientas estándar, se dará cuenta del huésped seleccionada para la depuración es Estibador, y un nuevo botón etiquetado Acoplable:
Solución de depuración está presente (véase la Figura 93).
Figura 93: Los botones para iniciar una aplicación en un recipiente acoplable
Si hace clic en este botón de nuevo, Visual Studio 2017 será el primer paquete de la aplicación en un recipiente estibador, invocar acoplable
para acoger el recipiente, y luego iniciar la aplicación, ofreciendo el poderoso apoyo de costumbre, la depuración. Detrás de las escenas,
Visual Studio 2017 invoca el interfaz de línea de comandos ventana acoplable para producir recipientes de modo que, mientras el embalaje, la Salida
ventana muestra los mensajes procedentes de las herramientas de línea de comandos. Cuando se cambia a la configuración de lanzamiento
y construir la solución, las herramientas acoplables Visual Studio y generan una imagen optimizada que está listo para la producción y para su
publicación.
Ejecución de un contenedor de estibador en Azure
Microsoft Azure puede albergar recipientes Docker en Linux, y Visual Studio 2017 hace que sea extremadamente fácil de publicar un contenedor a
su espacio de trabajo Azure. Para lograr esto, haga clic en el nombre del proyecto en Explorador de la solución, a continuación, seleccione Publicar.
Se le pedirá que especifique un perfil de publicación (véase la Figura 94). Suponiendo que no hay perfiles de publicación aún no se ha creado, haga
clic
Crear.
120
Figura 94: Especificación de un perfil de publicación
Se le pedirá que especifique un destino de publicación inmediatamente. Seleccionar Azure Aplicación de servicio Linux
(Véase la Figura 95), a continuación, en DE ACUERDO.
121
Figura 95: Selección de Linux en Azure como el destino de publicación
En este punto, el Crear servicio de aplicaciones Aparece el diálogo. Aquí debe proporcionar alguna información importante que Visual
Studio 2017 necesidades con el fin de publicar un recipiente acoplable a Azure, tales como el nombre de la aplicación web, la suscripción
Azure, un grupo de recursos, un plan de servicio de aplicaciones, y un registro de contenedores. Algunos campos se rellenarán
automáticamente, incluyendo la suscripción Azure si Visual Studio detecta una asociada a la cuenta de Microsoft que utilizó para iniciar la
sesión (ver Figura 96).
122
Figura 96: Proporcionar información obligados a publicar un contenedor acoplable a Azure
Seleccionar los recursos que previamente creada en el Portal de Azure, a continuación, haga clic Crear. En este punto, Visual
Studio 2017 pondrá en marcha todos los servicios necesarios en Azure. Cuando finaliza la instalación, verá un resumen
incluyendo la URL que va a utilizar para iniciar la aplicación en contenedores (ver Figura 97). Después de revisar los resultados,
haga clic Publicar. Visual Studio 2017 empaquetar e implementar el contenedor acoplable con su solicitud a su suscripción Azure.
El progreso de la publicación será visible en el Publicar web ventana de la herramienta.
123
Figura 97: VS Resumen Antes de la publicación de la aplicación a acoplable
Si bien la publicación, acoplable se abrirá una ventana de consola que no se debe cerrar y que se apagará automáticamente. Cuando
Visual Studio 2017 termina la publicación de su aplicación web, usted será capaz de poner en marcha en su navegador favorito
usando la URL que ha recibido en el resumen. Esto lo hará exactamente como lo haría con cualquier otro sitio web o aplicación.
124
La introducción de capacidades de servicio
Para aplicaciones web y móviles, Visual Studio 2017 ha introducido una característica llamada Capacidades de servicio. Se trata de una
nueva forma de conectarse a un servicio, y que complementa los mecanismos de consulta más antiguas Añadir conectadas y añadir el
servicio. En Explorador de la solución, verá capacidades de servicio bajo un nombre de proyecto. Haga clic en él, a continuación,
seleccione Añadir Capacidad de Servicio ( puede seguir utilizando la aplicación de ejemplo ASP.NET Core web creada con anterioridad).
El número de servicios disponibles varía dependiendo de su configuración, pero Visual Studio 2017 muestra una ventana nueva
herramienta llamada Capacidades de Servicio donde se puede encontrar una lista de servicios disponibles (ver Figura 98).
Figura 98: La lista de los servicios relacionados disponibles
Si hace clic en el Encuentra más servicios hipervínculo, Visual Studio muestra el Las extensiones y actualizaciones de diálogo,
más específicamente, se abre un nuevo nodo denominado Servicios conectados y muestra la lista de conexiones adicionales que
se pueden descargar, ya sea del mercado Estudio Visual (antes Galería Visual Studio) o la página web de un proveedor (véase la
Figura 99).
125
Figura 99: servicios conectados, además, a Descargar como extensiones
Puede descargar e instalar uno o más servicios adicionales. Recuerde que la lista que se muestra en la Figura 99 es sólo un ejemplo.
Volver a la Capacidades de Servicio ventana. En los pasos siguientes, voy a mostrar cómo funciona el asistente de conexión contra
una cuenta de almacenamiento de Azure. Para ello será necesario tener una suscripción activa Azure (la versión de prueba está muy
bien). Si usted no tiene que (o no desea crear uno), puede saltar a la siguiente sección. En términos generales, con capacidades de
servicio, Visual Studio 2017 simplifica el establecimiento de una conexión a un servicio, y se encarga de descargar los paquetes NuGet
que se requieren para trabajar en contra del servicio seleccionado. Si hace clic en Azure de almacenamiento, aparece un asistente y
requiere que se especifique si desea conectarse a una cuenta de almacenamiento existente o si desea crear uno nuevo (ver Figura
100).
126
Figura 100: El Asistente de almacenamiento Azure
Si hace clic Crear una nueva cuenta de almacenamiento, el Crear una cuenta de almacenamiento Aparece el diálogo (ver Figura 101). Aquí se
especifique su suscripción Azure, el nombre de la cuenta de almacenamiento, y la información requerida, tales como el nivel de precio, ubicación,
y el grupo de recursos.
Figura 101: Crear una nueva cuenta de almacenamiento
127
Al hacer clic Crear, o si selecciona Añadir en el Azure Storage diálogo para una cuenta existente, Visual Studio 2017
se conectará a Azure, lleve a cabo las operaciones necesarias, y descargar e instalar el NuGet empaqueta la
aplicación necesita interactuar con el servicio seleccionado de C #. La figura 102 muestra este.
Figura 102: descarga de los paquetes NuGet apropiados
Los paquetes NuGet hace referencia también son visibles en Explorador de la solución, como se esperaba. La figura 103 muestra cómo Explorador
de la solución muestra los paquetes descargados NuGet (en este caso
WindowsAzure.Storage) y una nueva carpeta, que tiene el nombre de su cuenta de almacenamiento más el sufijo AzureStorage.
Esta carpeta contiene un archivo ConnectedService.json, que mantiene la información de dependencia, y una Empezando archivo de
información que apunta a la página de documentación apropiada para el servicio seleccionado.
128
Figura 103: Explorador de soluciones Muestra NuGet paquete y una nueva carpeta Soporte
En este caso particular, si hace doble clic Empezando, Visual Studio se abrirá una página llamada
Comience con el almacenamiento de Azure burbuja y Servicios de Visual Studio conectado (ASP.NET) . Aquí encontrará ejemplos
de código en C # que se puede utilizar para interactuar con la cuenta de almacenamiento de nueva creación dentro de sus usos.
Vale la pena recordar que, independientemente del servicio conectado a elegir, Visual Studio 2017 se encarga de establecer una
conexión y la descarga y la instalación de los paquetes apropiados NuGet.
Creación de aplicaciones Node.js
Visual Studio 2017 tiene soporte completo para la construcción Node.js aplicaciones. Node.js es una fuente muy popular abierto, multiplataforma, y el
tiempo de ejecución de JavaScript orientado a eventos para el desarrollo de una variedad de aplicaciones. Visual Studio 2017 incluye plantillas de
proyecto que puede utilizar para construir rápidamente una serie de aplicaciones Node.js, incluyendo aplicaciones web, aplicaciones de consola, y las
aplicaciones habilitadas para Azure.
129
Nota: Node.js apoyo y la integración sólo está disponible si se instala la carga de trabajo de desarrollo
Node.js.
Las plantillas de proyecto para Node.js están disponibles bajo la JavaScript nodo en el Nuevo proyecto
de diálogo, como se muestra en la Figura 104.
Figura 104: plantillas de proyecto para Node.js
Los nombres de plantilla son bastante explica por sí mismo, y la Nuevo proyecto diálogo proporciona una buena descripción cuando se
selecciona uno. Sólo un breve comentario sobre la plantilla llamada De Node.js código existente: esto le permite importar código o activos
existentes de los archivos en el disco con diferentes extensiones. La Figura 105 muestra el asistente de importación con la lista de archivos
compatibles. Puede incluir extensiones adicionales en el cuadro de texto en la parte inferior, y se puede especificar el elemento de inicio en la
segunda página del asistente. Por último, se importa la carpeta especificada.
130
Figura 105: Diálogo que las importaciones vigente Código Node.js
Nota: Algunas plantillas de proyecto de apoyo expreso 4. Este es un marco Node.js para aplicaciones web que proporciona
un conjunto de características, utilidades y APIs para web y aplicaciones para móviles. Se puede obtener más información
sobre Express 4 en expressjs.com .
Cualquiera que sea la plantilla que elija, Visual Studio 2017 genera un proyecto que contiene los siguientes elementos visibles en Explorador
de la solución:
• Un archivo JavaScript (app.js para aplicaciones de consola o server.js para aplicaciones web) que contiene el código de arranque
mínimo.
• Un archivo package.json que contiene información sobre la aplicación.
• Un archivo README.md vacía que se puede utilizar para escribir la documentación utilizando el lenguaje de marcado de rebajas.
• El nodo Nodo Package Manager (NPM), que se puede hacer clic derecho a gestionar, descargar e instalar los paquetes
de la NGP para Node.js. El comando puede seleccionar es Instalar nuevos paquetes NGP.
131
Consejo: NPM es el gestor de paquetes para aplicaciones de JavaScript. Si eres nuevo en el desarrollo de
JavaScript, se puede comparar a la NGP NuGet en el desarrollo .NET.
La Figura 106 muestra el Instalar nuevos paquetes NGP diálogo en acción. Comienza a escribir los nombres de paquete en el cuadro de búsqueda y el cuadro
de diálogo mostrará una lista de paquetes que coinciden a medida que escribe.
Figura 106: Gestión de Paquetes de NPM
Con cualquiera de las plantillas, puede escribir código JavaScript y aprovechar las herramientas integradas conocidos y
potentes en Visual Studio, tales como:
• La disponibilidad total de IntelliSense.

• Las herramientas de diagnóstico y elaboración de perfiles.
• Examen de la unidad.
• control de código fuente basado en Git.
• Integración con el texto mecanografiado.
• Herramientas de depuración, incluyendo puntos de interrupción y ventanas de depuración.
Como ejemplo, la Figura 107 muestra el depurador en la acción sobre una aplicación web en blanco en modo de descanso después de un punto de
interrupción es golpeado.
132
Figura 107: Soporte de depuración completa de aplicaciones Node.js
Como se puede ver, Node.js recibe soporte de depuración completa con puntos de interrupción, puntas de datos y depuración de Windows, tales como
Los locales. Más información acerca de Visual Studio 2017 utillaje para Node.js se puede encontrar en www.visualstudio.com/vs/node-js .
herramientas actualizadas para Microsoft Azure
Azure es la solución en la nube de Microsoft, y está creciendo rápidamente con los servicios nuevos y actualizados. Cuando se
selecciona la carga de trabajo de desarrollo de Azure, las descargas Visual Studio Installer e instala el último SDK Azure para .NET, que
se extiende Visual Studio 2017 con plantillas de herramientas, ventanas, y de proyectos integrados que permiten a los desarrolladores
trabajar en contra de la mayoría de los servicios de Azure dentro del IDE sin abrir el portal de Azure . nube Explorador es una de las
herramientas integradas que el SDK trae a Visual Studio 2017. En el momento de la escritura, el SDK Azure para .NET proporciona las
mismas funcionalidades a Visual Studio 2015, Visual Studio 2013 Update 4 y Visual Studio 2012 Actualización 2. Debido el número de
servicios de Azure que Visual Studio se integra con ha crecido tanto, y debido a que las herramientas de Azure no son específicos de
Visual Studio 2017, este capítulo sólo se resumen las herramientas que tiene con el SDK de Azure para .NET. Más tarde, puede
aprender más acerca de los servicios de Azure y herramientas en el documentación oficial . Observe que la lista de servicios y
herramientas puede variar en futuras versiones del SDK de Azure y Visual Studio.
133
He aquí un resumen de lo que hay de nuevo:
• Apoyo para Azul Lago de Datos , El nuevo servicio en la nube para grandes datos de Microsoft. Esto se ofrece a través de las
herramientas de Azure Lake datos para Visual Studio. En Visual Studio 2017, estos están disponibles cuando se instala el
almacenamiento de datos y la carga de trabajo de procesamiento. Más específicamente, las herramientas le permiten administrar
sus recursos de Lake Los datos de la nube Explorer y ofrece una serie de plantillas, como por T-SQL , HDInsight y Apache
tormenta proyectos.
• Apoyo para Azure Servicio Tela , Una plataforma que permite crear, depurar, probar e implementar aplicaciones
basadas en MICROSERVICE. Además del SDK de Azure, es necesario instalar el servicio de Azure Tela SDK, que
incluye herramientas integradas para Visual Studio. El SDK se puede descargar desde la Azure Descargas página y le
permite administrar una cuenta de servicio de la tela de la nube Explorer.
• El apoyo a la Administrador de recursos Azure , Que está disponible con la plantilla de proyecto de grupo de recursos Azure que se
puede utilizar para crear, configurar y desplegar los grupos de recursos en Azure. Con las herramientas de Visual Studio, ahora
puede administrar grupos de recursos dentro del IDE con la ayuda de la Esquema JSON ventana de la herramienta. En cuanto a
las herramientas del Administrador de Recursos Azure para Visual Studio, puede seguir a un funcionario tutorial en línea.
El punto culminante puntos anteriores, una vez más, la importancia de la nube Explorer como la herramienta integrada que utiliza para
trabajar con sus recursos Azure. La siguiente sección describe cambios a la nube Explorador con más detalle.
actualizaciones nube Explorador
Nube Explorer es una ventana de herramientas que interactúa con una o más suscripciones Azure dentro de Visual Studio. Con la
nube Explorer, puede ver y gestionar una serie de recursos sin salir del IDE. Por ejemplo, se pueden crear nuevas cuentas de
almacenamiento, gotas, tablas, colas, e incluso se puede administrar bases de datos SQL con la integración de la Explorador de
objetos de SQL Server
ventana de la herramienta. Comenzando con el SDK de Azure para .NET v. 2.9.6, Nube Explorador obtiene actualizaciones importantes. En primer
lugar, puede agrupar la vista por tipos de recursos o grupos de recursos a través del desplegable bajo el microsoft Azure etiqueta. En la figura 108,
se puede ver cómo el punto de vista aparece con el
Los grupos de recursos opción seleccionada, mientras que la Figura 109 muestra cómo la vista aparece con el
Tipos de recursos opción seleccionada. Tenga en cuenta que el número y tipo de elementos pueden variar en su máquina,
dependiendo de qué tipo de servicios en la nube se ha habilitado en su suscripción.
134
Figura 108: Vista de grupos de recursos en la nube Figura 109: Tipos de recursos Ver en la nube
Explorador Explorador
Cuando se selecciona un recurso, el Comportamiento pestaña en la parte inferior de la ventana mostrará una lista de acciones disponibles contra
ese recurso. Por ejemplo, si selecciona una base de datos SQL, las acciones disponibles se abrirá la base de datos en el portal de Azure, a
continuación, abra la base de datos en Visual Studio a través
Explorador de objetos de SQL Server, a continuación, actualice la vista. Las acciones disponibles varían en función del recurso seleccionado.
los propiedades pestaña muestra información sobre el recurso seleccionado (si está disponible). Si ha instalado el almacenamiento de datos y
la carga de trabajo de procesamiento y se ha suscrito al servicio Azure Lago de datos, verá un nodo denominado Análisis de datos Lake. Esto
le permite administrar los recursos del lago de datos fácilmente, crear bases de datos, insertar tablas, y escribir guiones. Figura 110
proporciona una vista de muestra de una base de datos creada dentro de la nube Explorer y una mesa actualmente en modo de diseño, con
herramientas y editores integrados específicos.
135
Figura 110: Gestión de Datos Azure Lake Resources
Del mismo modo, si ha instalado el SDK Azure Servicio de Tela, usted será capaz de gestionar recursos relacionados con este
servicio directamente desde dentro de la nube Explorer.
Visual Studio 2017 introduce importantes herramientas para el desarrollo multiplataforma y las dos cosas cloud- que a menudo
van de la mano. Probablemente, la adición más importante es utillaje para .NET Core, la, cruz-plataforma modular, el tiempo de
ejecución de código abierto que los desarrolladores pueden utilizar para construir la consola web y de aplicaciones para Linux,
Mac y Windows usando C #. Con las herramientas integradas, se puede construir soluciones .NET Core del mismo modo que con
el desarrollo clásico de .NET. Otra adición es fundamental para herramientas acoplable, una de facto standard in deploying
applications to containers. Docker containers can be hosted on Linux in Azure, and Visual Studio 2017 does the entire job of
packaging and deploying a container for you. In conjunction with its aim to be the development environment for any developer on
any platform, Visual Studio 2017 has full support for Node.js, including advanced editing, debugging, and testing features. Finally,
Visual Studio 2017 supports all the most recent Azure services, including Data Lake and Service Fabric, and it provides an option
for interacting with more services from within the IDE through the Cloud Explorer tool window. This avoids the need for opening
the Azure portal every time.
136

Visual Studio

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Visual Studio

Caricato da

Copyright:

Formati disponibili

Visual Studio 2017

Prólogo de Daniel Jebaraj

Todos los derechos reservados.

yo mportante información de licencias. Por favor lee.

Este libro tiene licencia para sólo lectura si se obtiene de www.syncfusion.com .

Este libro se licencia exclusivamente para uso personal o educativo.

Está prohibida la redistribución en cualquier forma.

de, fuera de, o en relación con la información de este libro.

Uso constituirá la aceptación de los términos mencionados.

marcas comerciales registradas de Syncfusion, Inc.

Crítico técnica: James McCaffrey

Editor de copia: John Elderkin

Coordinador de adquisiciones: Tres Watkins, gerente de desarrollo de contenidos, Syncfusion, Inc.

La historia detrás de la serie de libros Sucintamente .......................................... ......................................... 8

Sobre el Autor ............................................... .................................................. ...................................... 10

Introducción ................................................. .................................................. ............................................ 11

Capítulo 1 Una nueva experiencia de instalación ............................................ .................................................. 12

La solución de la complejidad de la instalación de Visual Studio .......................................... ............................... 12

Instalar Visual Studio 2017 .............................................. .................................................. .................. 12

Personalización de la instalación con componentes individuales ............................................ ........................... 15

Instalación de varias ediciones ............................................... .................................................. ..................... 17

Modificación de la instalación de Visual Studio 2017 ............................................ ............................................ 17

El lanzamiento de Visual Studio 2017 .............................................. .................................................. ............... 17

Resumen del capítulo ................................................ .................................................. ................................ 17

Capítulo 2 La página de inicio Revisited ............................................ .................................................. ......... 18

experiencia de arranque optimizado ............................................... .................................................. ................... 18

Mantenerse al día: Anuncios y noticias .......................................... ........................................... 19

Atajos para soluciones, proyectos y carpetas .......................................... ............................................... 20

Trabajar con proyectos utilizados más recientemente ............................................ ............................................... 20

Acceder a las plantillas de proyecto ............................................... .................................................. ............... 21

Abrir proyectos, carpetas y repositorios de control de código fuente ........................................ ................. 21

Resumen del capítulo ................................................ .................................................. ................................ 21

Capítulo 3 Código Editor Mejoras ............................................. .................................................. .... 22

mejoras de IntelliSense ................................................ .................................................. ................... 22

Código de navegación más fácil .............................................. .................................................. ................ 23

Encuentra todas las referencias ............................................... .................................................. ............................. 24

Navegando código con Ir a ............................................. .................................................. .................. 26

análisis de código Roslyn ............................................... .................................................. ............................ 28

Más refactorizaciones Roslyn ............................................... .................................................. .................... 28

El control de análisis en vivo con estilo de código ............................................ .................................................. 32

mejoras de edición para C ++ y F # ............................................ .................................................. ..... 47

Resumen del capítulo ................................................ .................................................. ................................ 47

Capítulo 4 Mejoras XAML .............................................. .................................................. .............. 48

XAML Editar y continuar .............................................. .................................................. ........................ 48

XAML mejoras editor de código .............................................. .................................................. ........... 49

Navegando código con Ir a ............................................. .................................................. .................. 50

IntelliSense filtrado ................................................ .................................................. ............................ 50

espacios de nombres de refactorización ................................................ .................................................. ................... 50

XAML Diagnóstico ................................................ .................................................. ................................ 53

Resumen del capítulo ................................................ .................................................. ................................ 55

Capítulo 5 Trabajar con las soluciones, carpetas y Idiomas ........................................ ...................... 56

Ligera carga Solución ............................................... .................................................. ..................... 56

soporte de lenguaje extendido ............................................... .................................................. .................. 57

Abrir carpeta: El uso de cualquier código base ........................................... .................................................. 58

La creación de la demo .............................................. .................................................. ............................. 58

soporte de lenguaje Basic en Visual Studio 2017 ........................................... ......................................... 59

Resumen del capítulo ................................................ .................................................. ................................ 74

Capítulo 6 Extensiones y extensibilidad ............................................. .................................................. 75 ..

Itinerancia Administrador de extensiones ............................................... .................................................. ............. 75

La programación de las operaciones sobre las extensiones de .............................................. ................................................. 76

Crear una extensión en blanco para fines de demostración ........................................... ........................................ 78

Especificación de requisitos previos de extensión ............................................... .................................................. ..... 79

el apoyo y el archivo de instalación personalizada NGEN ............................................ ................................................ 81

Resumen del capítulo ................................................ .................................................. ................................ 82

Trabajar con proyectos usados más recientemente