Visual Studio 2015 PDF - En.es

1
Visual Studio 2015

Sucintamente
Por
Alessandro Del Sole
Prólogo de Daniel Jebaraj
2
Copyright © 2015 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: Matt Duffield

Editor de copia: Benjamin bola
Coordinador de adquisiciones: Hillary Bolos, coordinador de marketing, Syncfusion, Inc.
Corrector de pruebas: Morgan Cartier Weston, productor de contenidos, Syncfusion, Inc.
3
Tabla de contenido
La historia detrás de la Sucintamente Serie de Libros ............................................... .................................... 7
Sobre el Autor ............................................... .................................................. ........................................ 9
Introducción ................................................. .................................................. ............................................ 10
Capítulo 1 Cuenta de Gestión de la Experiencia ............................................. ........................................... 11
Administración de cuentas ................................................ .................................................. .......................... 11
Automático de sesión de Servicios de Microsoft ............................................ .................................................. . 14
Resumen del capítulo ................................................ .................................................. ................................ dieciséis
Capítulo 2 proyectos compartidos .............................................. .................................................. ...................... 17
La comprensión de los proyectos compartidos ............................................... .................................................. ............ 17
La creación y consumo de proyectos compartidos ............................................. ............................................... 17
Resumen del capítulo ................................................ .................................................. ................................ 30
Capítulo 3 Código Editor Mejoras ............................................. .................................................. ..... 31
Gestos táctiles ................................................ .................................................. ................................... 31
La información sobre herramientas coloreadas ................................................ .................................................. ................................ 31
Bombillas y Acciones rápidas ............................................. .................................................. ................ 32
Encontrar y corregir código redundante ............................................. .................................................. .... 33
La fijación de errores ................................................ .................................................. ....................................... 34
La aplicación de Refactorizaciones ................................................ .................................................. ........................ 38
Capítulo 4 XAML Editor Mejoras ............................................. .................................................. .... 48
Definición vistazo en el Editor de código XAML ........................................... .................................................. . 48
Consideraciones adicionales para Peek Definición En XAML ........................................... ............................ 51
4
Las personalizaciones IDE Capítulo 5: Disposición de la ventana ........................................... ......................................... 53
Ventana Diseño personalizado ............................................... .................................................. ........................ 53
El ahorro de ventana Presentaciones ............................................... .................................................. ..................... 53
La aplicación de la ventana Presentaciones ............................................... .................................................. ................... 55
La gestión de ventanas diseños personalizados .............................................. .................................................. .... 56
Restaurando el diseño predeterminado .............................................. .................................................. .............. 57
Capítulo 6 Error Lista Revisited y depuración Mejoras .......................................... .................. 58
La lista de errores Revisited .............................................. .................................................. ......................... 58
Las mejoras de depuración ................................................ .................................................. .................... 61
Soporte para Expresiones Lambda Depuración ............................................. ........................................ 61
La visualización de información sobre herramientas de rendimiento: PerfTips ............................................. ............................................ 63
Herramientas diagnosticas ................................................ .................................................. ................................ 71
La gestión de puntos de interrupción con la configuración del punto de interrupción ............................................. .................................... 72
Capítulo 7 Gestión de paquetes NuGet ............................................. .................................................. .... 76
Una nueva NuGet ............................................... .................................................. ........................................ 76
Configuración de las preferencias NuGet ............................................... .................................................. ................. 78
Capítulo 8 Visual Studio 2015 para ASP.NET y Azure ....................................... .................................. 80
Requisitos previos Capítulo ................................................ .................................................. .......................... 80
Visual Studio 2015 para ASP.NET 5 .......................................... .................................................. ............ 81
Plantillas de proyecto Core 5 ASP.NET ........................................... .................................................. ....... 81
Un sistema nuevo proyecto .............................................. .................................................. ......................... 83
Las mejoras de IntelliSense ................................................ .................................................. ................ 86
Visual Studio 2015 para Microsoft Azure ............................................ .................................................. 88 ..
5
De inicio rápido ................................................ .................................................. ....................................... 88
Herramientas del Gestor de Recursos Azure .............................................. .................................................. .......... 92
Soporte para múltiples cuentas de Microsoft ............................................. ................................................. 98
Carpetas de almacenamiento Blob ............................................... .................................................. .......................... 99
La adición de servicios conectados ............................................... .................................................. ............. 101
Análisis de código de Azure .............................................. .................................................. .................... 103
Soporte HDInsight ................................................ .................................................. ............................ 105
Introduciendo WebJobs ................................................ .................................................. ....................... 108
Resumen del capítulo ................................................ .................................................. .............................. 111
Capítulo 9 Visual Studio 2015 para el desarrollo móvil .......................................... ............................ 112
El fondo ................................................ .................................................. ................................. 112
¿Qué aplicaciones móviles puedo construir con VS 2015? .................................................. ................................... 112
Requisitos previos ................................................. .................................................. ..................................... 113
Aplicaciones para iOS edificio .............................................. .................................................. ......................... 114
La creación de aplicaciones con Apache Cordova ............................................. .................................................. ..... 115
Visual Studio Tools para Apache Cordova ............................................ ............................................... 115
Resumen del capítulo ................................................ .................................................. .............................. 122
6
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é.
7
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
[email protected] .
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!
8
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 considerado internacionalmente un experto en Visual Studio y una autoridad de Visual Basic. Alessandro
ha sido autor de muchos libros impresos y libros electrónicos sobre la programación con Visual Studio, que incluye Visual Studio
2013 Sucintamente, Visual Basic 2015 Unleashed, Visual Studio LightSwitch Unleashed, y Visual Basic 2010 liberado. Ha escrito
toneladas de 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 el Centro de desarrollo de Visual Basic desde 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. Lo puedes seguir en Twitter en @progalex .
9
Introducción
Microsoft Visual Studio 2015 es la nueva versión del popular entorno de desarrollo integrado para la creación de aplicaciones modernas y
de alta calidad para una serie de plataformas como Windows, la Web, la nube y los dispositivos móviles. Continuando en lo que hizo
Microsoft con Visual Studio 2013, la versión de 2015 todavía se centra en el aumento de la productividad del desarrollador, mejorando el
editor de código, herramientas de depuración, integración Azure con otros servicios que requieren una cuenta de Microsoft, y mucho
más. Además, Visual Studio 2015 proporciona soporte a nuevas estrategias en Microsoft, como Windows 10, el código abierto-NET y
aplicaciones multi-plataforma de construcción para dispositivos móviles. Visual Studio 2015 se suministra con las siguientes ediciones:
Enterprise, Professional y la libre Community Edition. La mayoría de las funciones descritas en este libro requieren Visual Studio 2015
Professional, pero algunos de ellos requieren Visual Studio 2015 Enterprise, que es la edición más completa disponible. Voy a especificar
dónde se requiere la edición Enterprise. Para una comparación completa de las ediciones, y para una descarga de un ensayo
completamente funcional de 90 días de Visual Studio 2015 para empresas y otras ediciones, visite el Visual Studio Descargas página.
Este libro contiene una descripción completa de las nuevas características en el Studio 2015 IDE Visual que no sólo ayudará a escribir
mejor código, sino que también ayudará a ahorrar tiempo mientras que la interacción con los servicios en el ecosistema de Visual Studio.
El enfoque en Microsoft Visual Studio 2015 es la productividad, y este libro sigue el mismo punto de vista en la presentación de los
temas.
Este libro está dedicado a mi madre. Te extraño.
Alessandro
10
Capítulo 1 Cuenta de Gestión de Experiencia
Como aprendió de mi libro anterior, Visual Studio 2013 Sucintamente, Visual Studio 2013, por primera vez dio a los desarrolladores la
capacidad de iniciar sesión en Visual Studio mediante su cuenta de Microsoft. Aunque no es obligatorio, esto proporciona muchos beneficios,
tales como el desbloqueo de Visual Studio si usted es un suscriptor de MSDN, de forma permanente desbloquear ediciones Studio Express
Visuales (sustituido ahora por la Comunidad de Visual Studio), y que se extiende un período de prueba. Lo más importante, los
desarrolladores pueden aprovechar las configuraciones sincronizadas, que se desplazan entre múltiples instalaciones de Visual Studio; esto
significa que tendrán automáticamente la misma configuración en cualquier equipo que utilizan. Como aprenderá en este capítulo, Visual
Studio 2015 permite además posibilidades adicionales a través de iniciar sesión con una cuenta de Microsoft.
Administración de cuentas
Visual Studio 2015 se extiende el signo En la experiencia mediante el apoyo a varias cuentas de Microsoft para iniciar sesión en el
entorno de desarrollo. Tener varias cuentas para iniciar sesión en Visual Studio es común para las siguientes razones:
• cuentas separadas para desarrollar y probar aplicaciones (u otros fines).

• cuentas separadas para el trabajo y el hogar.
• cuentas separadas para múltiples desarrolladores que trabajan en una sola máquina.
Para simplificar la gestión de cuentas, utilice el Configuraciones de la cuenta ventana. Tiene dos opciones para iniciarlo:
• Seleccionar Expediente > Configuraciones de la cuenta.
• Haga clic en el Configuraciones de la cuenta... hipervínculo situado bajo la información del perfil actual, disponible en la
esquina superior derecha de la IDE (ver Figura 1).
Figura 1: Localización de la Configuraciones de la cuenta hiperenlace.
Suponiendo que sólo tiene una cuenta de Microsoft asociada con Visual Studio, la ventana de configuración de la cuenta debe
recibir la Figura 2.
11
Figura 2: La ventana de configuración de la cuenta.
Como se puede ver, Visual Studio 2015 muestra información resumida sobre el usuario actual. En la parte inferior, se
encuentra la Todas las cuentas grupo, que contiene la lista de cuentas de Microsoft asociados; la lista permite agregar y
eliminar cuentas. Para añadir otra cuenta, haga clic en el
Agregar una cuenta… hiperenlace. En este punto, Visual Studio requiere la especificación de la cuenta de Microsoft que desea agregar,
como se muestra en la Figura 3.
Figura 3: Agregar una cuenta de Microsoft Visual Studio 2015.
Si esta es la primera vez que se utiliza la cuenta para iniciar sesión, Visual Studio 2015 también creará un nuevo perfil en línea, que se
requiere para la sincronización de la información y el registro de una cuenta en
Visual Studio Online (Anteriormente conocido como Equipo de Servicio Fundación). Si este es tu caso, Visual Studio le pedirá que especifique la
información de identidad básica, como se muestra en la Figura 4.
12
Figura 4: Especificación de información de identidad básica al crear un nuevo perfil en línea.
Consejo: Puede editar el perfil en línea para una cuenta de Microsoft seleccionando Administración de Visual Studio perfil en el
grupo Cuenta Personalización de la ventana Configuración de la cuenta. También será capaz de especificar una imagen y ver la
lista de Studio memeberships cuenta en línea visual asociada con el perfil.
Una vez que se haya creado el perfil en línea, o si no es la primera vez que utiliza la cuenta, el
Configuraciones de la cuenta ventana se actualizará la lista de cuentas de Microsoft asociados, como se representa en la figura 5.
Figura 5: La lista actualizada de cuentas disponibles.
13
De esta manera, usted tiene un lugar centralizado para gestionar las cuentas, y cada cuenta de Microsoft puede tomar ventaja de los
beneficios como la configuración sincronizados. Cuando haya terminado la gestión de cuentas, simplemente haga clic Cerca o cerrar sesión
de la cuenta corriente y abrir una sesión con una diferente.
Consejo: No es necesario cerrar un proyecto abierto al cambiar de cuentas.
Inicio de sesión automático de Servicios de Microsoft
Cuando se construye una aplicación con Visual Studio 2015, puede que tenga que acceder a muchos servicios de Microsoft, como
su suscripción Azure, Visual Studio cuenta en línea, Perspectivas de Aplicación (alojados en Azure), Azure Mobile Services o
Windows tienda de suscripción desarrollador.
AVISO: La Insights es actualmente un servicio de previsualización alojado en su suscripción Microsoft Azure, que permite la
monitorización en vivo y telemetría para la disponibilidad, el rendimiento y el uso de aplicaciones web y móviles. Puede
activar Insights de aplicación cuando se crea un proyecto para una aplicación web o móvil. El apoyo a la aplicación Insights
se introdujo en Visual Studio 2013 Actualización 2, por lo que no está siendo tratado aquí. Puede encontrar información
adicional aquí .
Todos los servicios antes mencionados requieren iniciar sesión con una cuenta de Microsoft. En Visual Studio 2015, al iniciar
sesión, el IDE se conectará automáticamente la cuenta corriente a cualquier servicio de Microsoft asociado; usted no tendrá que
introducir sus credenciales cada vez. Por ejemplo, si la cuenta de Microsoft que utiliza para iniciar sesión es también una cuenta de
administrador en una suscripción Microsoft Azure, Visual Studio 2015 se conectará automáticamente la ventana Explorador de
servidores a la suscripción Azure, por lo que va a ser inmediatamente capaz de interactuar con los servicios de dentro de la IDE; si
se establece previamente un Visual Studio cuenta en línea, Visual Studio se conectará automáticamente a la cuenta y hacer control
de código fuente disponible de inmediato. Adicionalmente, Visual Studio 2015 hace que sea fácil para seleccionar una cuenta al
crear servicios conectados o cuando la creación de Insights de aplicación. Por ejemplo, la figura 6 muestra ambos Team Explorer
conectados a Visual Studio en línea y la opción de elegir una de las cuentas asociadas al acceder a una suscripción.
14
Figura 6: Inscripción fácil a los servicios con cuentas de Microsoft.
La figura 7 muestra lo fácil que es la elección de una cuenta de Microsoft cuando se añade Insights aplicación de telemetría para un nuevo
proyecto (esto requiere una suscripción activa Azure).
Figura 7: La elección de una cuenta de Microsoft para la aplicación Insights.
15
Vale la pena mencionar que, al iniciar sesión con una cuenta de Microsoft, Visual Studio 2015 no almacena ninguna de sus
credenciales. Autenticación sucede contra un proveedor de identidad basada en la web, que puede ser el proveedor de cuentas de
Microsoft Active Directory o el Azure. Si la autenticación tiene éxito, el proveedor de identidad da algunos tokens de autenticación
de Visual Studio, que permite a Visual Studio 2015 para manejar los tokens de autenticación segura.
Resumen del capítulo
Visual Studio 2015 amplía y mejora la señal en la experiencia mediante la introducción de soporte para múltiples cuentas de Microsoft
y al permitir la conexión automática a los servicios de Microsoft que están asociados a la cuenta que ha iniciado sesión. Sin lugar a
dudas, esto hace que sea más fácil conectarse al servicio y mejora la productividad evitando la necesidad de cerrar la sesión y luego
iniciar sesión de nuevo con diferentes cuentas.
dieciséis
Capítulo 2 proyectos compartidos
Una de las características más deseables para los desarrolladores es la capacidad de escribir código una vez y compartir ese código a través
de múltiples tipos de aplicaciones. Visual Studio 2015 simplifica el proceso de compartir código con la introducción de proyectos compartidos.
Si ha creado aplicaciones de Windows universal en el pasado con 2013 Actualización 2 o superior Visual Studio, usted tiene una idea de lo
que es un proyecto compartido, pero ahora se puede utilizar para compartir código entre tipos de proyectos adicionales. Este capítulo trata de
proyectos compartidos y explica su estructura y su uso.
Nota: En este capítulo se supone que tiene alguna experiencia con la creación y gestión de soluciones y proyectos,
añadiendo referencias a otros proyectos, y que ya conoces la terminología para estas tareas.
La comprensión de los proyectos compartidos
Proyectos compartido permite el intercambio de código, los activos y recursos a través de múltiples tipos de proyectos. Más específicamente, los siguientes
tipos de proyectos pueden hacer referencia a consumir y proyectos compartidos:
• Consola, Windows Forms y Windows Presentation Foundation.

• Tienda de Windows 8.1 aplicaciones y Windows Phone 8.1 aplicaciones.
• Windows Phone 8.0 / 8.1 aplicaciones Silverlight.

• Bibliotecas de clases portátiles.
Visual Studio 2013 Actualización 2 proyectos compartidos introdujo por primera vez para proporcionar una oportunidad fácil de construir aplicaciones
de Windows universal de soporte de Windows 8.1 / Windows Phone 8.1 par; Ahora, los proyectos compartidos están disponibles para todos los
proyectos antes mencionados y para C # y Visual Basic. Lo importante subrayar es que no sólo compartir código, sino también los bienes y recursos,
tales como (pero no limitado a) las imágenes y plantillas XAML. Técnicamente hablando, los proyectos compartidos son surtidos sueltos de archivos
que se agregan a continuación, los archivos vinculados exactamente igual, a lo que ellas hacen referencia a proyectos. Que en realidad no se
dirigen a ningún subconjunto específico .NET y no producen una biblioteca .dll; detrás de las escenas, cuando la construcción de su solución, la
herramienta se ejecuta contra MSBuild proyectos compartidos las mismas reglas que para los archivos vinculados.
La creación y consumo de proyectos compartidos
proyectos compartidos están disponibles a través de plantillas de proyectos específicos en el Nuevo proyecto diálogo. Para entender cómo funcionan,
crear una nueva solución que contiene un proyecto compartido, un proyecto de WPF, y un proyecto de aplicación de Windows 8.1 tienda. En Visual
Studio 2015, seleccione Expediente > Nueva > Proyecto.
En lugar de crear un nuevo proyecto directamente, crear una nueva solución en blanco seleccionando Solución en blanco debajo Otros tipos
de proyectos / Studio (Visual Solutions véase la Figura 8). Nombre de la nueva solución SharingSample y haga clic OKAY.
17
Figura 8: Creación de una solución en blanco.
El siguiente paso es añadir el proyecto compartido. Puede o bien haga clic en el nombre de la solución en el Explorador de soluciones y
seleccione Añadir > Proyecto Nuevo o seleccione Expediente > Añadir > Nuevo proyecto. Como se puede ver en el Agregar nuevo proyecto de
diálogo (ver Figura 9), el Proyecto compartido plantilla está disponible en la lista. Puede seleccionar C # o Visual Basic (habrá un ejemplo para
ambos).
Figura 9: Adición de un proyecto compartido.
Se puede elegir cualquier nombre que desee o deje el nombre predeterminado y haga clic OKAY. Como se puede ver en el Explorador de
soluciones, el proyecto compartido tiene una estructura muy simple; está representado por un icono verde, como se muestra en la Figura 10.
18
Figura 10: El proyecto compartido en el Explorador de soluciones.
Nota: Detrás de las escenas, los proyectos compartidos están representados por archivos con la extensión .shproj, que básicamente
contiene las reglas de MSBuild necesarios para el proceso de compilación, además de un archivo con la extensión .projitems, que en su
lugar contiene la lista de elementos para ser compartida.
El objetivo de un proyecto compartido es hacer que sea más fácil compartir código, los recursos y activos. Añadir tres carpetas para el proyecto
denominado Código, Recursos, y Bienes. Ahora, supongamos que desea compartir una plantilla XAML, una imagen, y algo de código entre un
proyecto WPF y un proyecto de tienda de Windows 8.1. Haga clic con el Código carpeta y seleccione Añadir > Nuevo elemento. En el Agregar
ítem nuevo
de diálogo, seleccione la Clase la plantilla y el nombre de la nueva clase (Person.cs véase la Figura 11).
Figura 11: Adición de una clase compartida.
19
El ejemplo de código contiene una definición de la Persona clase y una colección llamada
Gente, que contiene algunos casos de muestras de la Persona clase.
C # Código Ejemplo
utilizando System.Collections.ObjectModel;
espacio de nombres SharedProject1 {
público clase Persona

{
público cuerda Primer nombre { obtener ; conjunto ; }
público cuerda Apellido { obtener ; conjunto ; }
public int Años { obtener ; conjunto ; }}
público clase Gente : ObservableCollection < Persona > {
público Gente() {
// Añadir datos de la muestra

var p1 = nuevo Persona (); p1.LastName = "Del
Sole" ; p1.FirstName = "Alessandro" ; p1.Age =
37;
var p2 = nuevo Persona (); p2.LastName

= "Blanco" ; p2.FirstName = "Robert" ;
p2.Age = 40;
esta .Add (p1);

esta .Add (p2);
}}}
Ejemplo de código de Visual Basic
Las importaciones System.Collections.ObjectModel
Público Clase Persona

Público Propiedad Primer nombre() Como public String Propiedad
Apellido() Como public String Propiedad Años() As Integer
End Clase
Público Clase Gente
20
hereda ObservableCollection ( De Persona )
Public Sub New ()

'Añadir datos de la muestra
Oscuro p1 = Nuevo Persona () =
P1.LastName "Del Sole"
p1.FirstName = "Alessandro"
p1.Age = 37
Oscuro p2 = Nuevo Persona () =

P2.LastName "Blanco"
p2.FirstName = "Robert"
p2.Age = 40
Yo .Add (p1)
Yo .Add (p2)
End Sub
End Clase
los Gente recogida de datos es el que tanto la tienda de las aplicaciones de Windows WPF y se mostrarán en la pantalla; ya que
ambos tipos de aplicaciones se basan en XAML, es una buena idea para crear una plantilla de datos que será compartida en la
solución. Para lograr esto, haga clic en el recursos
carpeta y seleccione Añadir > Nuevo artículo. En el Agregar ítem nuevo de diálogo, busque el XAML nodo y seleccione Diccionario de recursos, como
se muestra en la Figura 12.
Figura 12: Adición de un diccionario de recursos compartidos.
21
En el código se especifica una nueva DataTemplate objeto, que contiene algunas Bloque de texto controles, dispuesto dentro de StackPanel
contenedores, que están enlazados a las propiedades de la Persona clase.
< ResourceDictionary
xmlns = "Http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns : X = "Http://schemas.microsoft.com/winfx/2006/xaml">
< DataTemplate X : Llave = "MiPlantilla">

< Frontera Anchura = "240" BorderBrush = "Negro" BorderThickness = "2" Margen = "3">
< StackPanel Orientación = "Vertical" Margen = "3">
< StackPanel Orientación = "Horizontal">
< Bloque de texto Texto = "Apellido" FontWeight = "Bold" /> < Bloque de texto Texto
= "{ Unión Apellido } "/> </ StackPanel > < StackPanel Orientación = "Horizontal">
< Bloque de texto Texto = "Nombre:" FontWeight = "Bold" /> < Bloque de texto Texto
= "{ Unión Primer nombre } "/> </ StackPanel > < StackPanel Orientación =
"Horizontal">
< Bloque de texto Texto = "Edad:" FontWeight = "Bold" /> < Bloque de
texto Texto = "{ Unión Años } "/> </ StackPanel >
</ StackPanel >

</ Frontera >
</ DataTemplate >
</ ResourceDictionary >
Con el fin de compartir con éxito el diccionario de recursos para ambos objetivos, debe quitar el siguiente alias de espacio de
nombres XML, que es específico de la tienda de Windows y Windows Phone.
xmlns: locales = " usando: SharedProject1.Resources "
El último paso en el proyecto compartido es la adición de una imagen de muestra. Haga clic con el Bienes carpeta y seleccione Añadir > Elemento
existente, a continuación, seleccione un archivo de imagen de su elección entre uno de los formatos de archivo compatibles, como JPG, PNG, GIF o BMP.
Con el fin de hacer que el archivo de imagen utilizable por WPF, en el propiedades establece la ventana Guardar en agenda de salida propiedad a Copiar
si es más reciente. La figura 13 muestra cómo aparece el proyecto compartido en el Explorador de soluciones y la forma de establecer la propiedad del
archivo de imagen en la ventana Propiedades.
22
Figura 13: El aspecto actual para el proyecto compartido.
En este punto, desea agregar el primer proyecto de cliente. Seleccionar Expediente > Añadir > Proyecto Nuevo y en el
Nuevo proyecto de diálogo seleccionar el Aplicación WPF plantilla de proyecto; por el bien de la consistencia del ejemplo, el nombre del
nuevo proyecto MyWPFApp ( véase la Figura 14).
23
Figura 14: Adición de un proyecto de cliente WPF.
Una vez que el proyecto está disponible, lo primero que debe hacer es añadir una referencia al proyecto compartido. Como te he dicho antes, los
proyectos compartidos no producen asambleas, por lo que añadir una referencia a un proyecto compartido significa en realidad la vinculación de archivos
de código en el proyecto compartido con el proyecto actual. Cuando se agrega una referencia a un proyecto compartido, la Reference Manager diálogo
muestra un nodo especial llamado Proyectos compartidos, donde se puede encontrar una lista de proyectos compartidos en su solución (ver Figura
15).
Figura 15: Adición de una referencia a un proyecto compartido.
24
Seleccione el proyecto compartido y haga clic OKAY.
Consejo: Si expande el nodo de referencia en el Explorador de soluciones, se verá que el icono para el proyecto compartido es
diferente que el icono de asambleas. Este es un recordatorio de que comparte proyectos no producen un conjunto.
En la aplicación de WPF que desee utilizar los recursos que residen en el diccionario de recursos compartidos. Para lograr esto, es
necesario agregar un diccionario de recursos en el archivo App.xaml (o Application.xaml en Visual Basic) como en el código siguiente.
< Application.Resources >

< ResourceDictionary >
< ResourceDictionary.MergedDictionaries > < ResourceDictionary Fuente = "/ Recursos /
Dictionary1.xaml" /> </ ResourceDictionary.MergedDictionaries >

</ Application.Resources >
Observe cómo se especifica la ubicación diccionario a través de un identificador uniforme de recursos relativa (URI), que incluye el nombre de la
subcarpeta en el proyecto compartido. No se preocupe si el Fuente valor de la propiedad está subrayado con un garabato de error (notificación de
error semántico), el diccionario de recursos sin duda será resuelta en tiempo de ejecución. La interfaz de usuario para la aplicación de ejemplo es
muy simple. En el MainWindow.xaml archivo, un lugar Cuadrícula envase; esto mostrará el archivo de imagen como el logotipo de aplicación y una Cuadro
de lista el control para presentar la lista de datos. Observe cómo se puede utilizar un URI relativo simplificada para que apunte al archivo de
imagen; el URI incluye el nombre de la subcarpeta tal como aparece en el proyecto compartido.
< Ventana X : Clase = "MyWPFApp.MainWindow"

xmlns : X = "Http://schemas.microsoft.com/winfx/2006/xaml"
xmlns : re = "Http://schemas.microsoft.com/expression/blend/2008"
xmlns : mc = "Http://schemas.openxmlformats.org/markupcompatibility/2006"
xmlns : local = "CLR-espacio de nombres: MyWPFApp" Cargado = "Window_Loaded"

mc : ignorable = "D"
Título = "MainWindow" Altura = "350" Anchura = "525"> < Cuadrícula > < Grid.RowDefinitions
> < RowDefinition Altura = "80" /> < RowDefinition /> </ Grid.RowDefinitions
>
<! - Reemplazar con un nombre de archivo de su elección ...-->

< Imagen Fuente = "../ SharedProject1 / Activos / LogoVBTT.jpg" />
25
< Cuadro de lista ItemTemplate = "{ StaticResource MiPlantilla }" Nombre = "DataBox"
Grid.Row = "1" />
</ Cuadrícula >
</ Ventana >
Como se destaca en el código, también tiene que proporcionar un controlador de eventos para el Window.Loaded
evento, que es el lugar donde se carga de datos. Relativa a la Cuadro de lista, se asigna el
DataTemplate llamado MiPlantilla, se define en el diccionario de recursos compartidos, como la plantilla de elementos para
presentar cada instancia de la Persona clase. los Window.Loaded controlador de eventos simplemente crea una instancia de la Gente
colección; la instancia se asigna a la
ListBox.ItemsSource propiedad para poblarlo.
C # Código Ejemplo
// Requiere una directiva utilizando SharedProject1.Code

private void Window_Loaded ( objeto remitente, RoutedEventArgs e) {
esta .DataBox.ItemsSource = nuevo Gente (); }
Private Sub Window_Loaded (remitente Como objeto , e Como RoutedEventArgs )

Yo .DataBox.ItemsSource = Nuevo Gente ()
End Sub
Consejo: Recuerde que C # define un espacio de nombres para cada subcarpeta en el proyecto que contiene el código. Por esta razón
hay que colocar una utilizando SharedProject1.Code directiva para importar contenido de la subcarpeta.
Si ahora ejecuta el proyecto de ejemplo, obtendrá un resultado similar a la Figura 16 (por supuesto, es probable que haya utilizado un archivo de
imagen diferente).
26
Figura 16: Adición de una referencia a un proyecto compartido.
Este es sin duda un ejemplo sencillo, pero el objetivo es entender cómo compartir diferentes tipos de recursos. En este punto, añadir una
nueva aplicación Windows Store utilizando el Aplicación en blanco (Windows 8.1)
plantilla, como se muestra en la Figura 17. Nombre del nuevo proyecto como MiApWindows y haga clic OKAY.
Figura 17: Adición de un proyecto de Windows Store.
27
Ahora haga lo siguiente:
• Añadir una referencia al proyecto compartido, exactamente igual que en el proyecto de WPF.
• En el archivo App.xaml (o Application.xaml en Visual Basic), agregue el mismo código XAML que ya escribió
en el App.xaml del proyecto WPF.
• En el archivo MainPage.xaml, añadir la misma Cuadrícula contenido de definición que ya escribió en el archivo
MainWindow.xaml del proyecto WPF.
Añadir un controlador de eventos para el Page.Loaded evento. El código XAML llena de MainPage.xaml es el siguiente.
< Página
X : Clase = "MyWindowsApp.MainPage"
xmlns : local = "Usando: MyWindowsApp" Cargado = "Page_Loaded"
xmlns : mc = "Http://schemas.openxmlformats.org/markup-compatibility/2006"
mc : ignorable = "D">
< Cuadrícula Fondo = "{ ThemeResource ApplicationPageBackgroundThemeBrush } ">

< Grid.RowDefinitions > < RowDefinition Altura = "80" /> < RowDefinition /> </ Grid.RowDefinitions > < Imagen
Fuente = "Activos / vbtt_logo.png" /> < Cuadro de lista ItemTemplate = "{ StaticResource MiPlantilla }" Nombre
= "DataBox"
Grid.Row = "1" />

</ Cuadrícula >
</ Página >
los Page.Loaded controlador de eventos es idéntico a su contraparte WPF, excepto que aquí se tiene una
Página preferible a Ventana.
C # Código Ejemplo
// Requiere una directiva utilizando SharedProject1.Code

private void PAGE_LOADED ( objeto remitente, RoutedEventArgs e) {
esta .DataBox.ItemsSource = nuevo Gente (); }
Private Sub PAGE_LOADED (remitente Como objeto , e Como RoutedEventArgs )

Yo .DataBox.ItemsSource = Nuevo Gente ()
End Sub
28
Establecer el proyecto de Windows Store como la puesta en marcha uno y pulse F5. Como se puede ver, la aplicación muestra la misma
imagen y datos, que ha sido presentado por el uso de la misma plantilla de datos como en la contrapartida WPF (ver Figura 18).
Figura 18: La tienda de Windows aplicación en ejecución.
Es fácil entender cómo puede aprovechar proyectos compartidos para compartir una variedad de artículos entre varios tipos de
proyectos, incluyendo el código, activos y recursos. Compartir XAML y C # código / VB es probablemente la oportunidad más
interesante que comparten proyectos ofrecen.
Nota: ambos proyectos compartidos y bibliotecas de clases portátiles (PCL) Permitir el uso compartido de códigos, recursos XAML, y
los activos, pero por supuesto hay algunas diferencias que podrían resumirse de la siguiente manera. Un proyecto compartido no
produce un conjunto reutilizable, por lo que sólo puede ser consumida dentro de la solución. Un proyecto compartido tiene soporte
para código platformspecific, porque es compatible con las variables de entorno, tales como
WINDOWS_PHONE_APP y WINDOWS_APP que se puede utilizar para detectar la plataforma que su código se está ejecutando.
Finalmente, los proyectos compartidos no pueden tener dependencias de las bibliotecas de terceros. En comparación, un PCL
produce una biblioteca .dll reutilizable y puede tener dependencias de bibliotecas de terceros, pero no soporta las variables de
entorno de la plataforma.
29
Presentado por primera vez en Visual Studio 2013 Actualización 2 para la creación de aplicaciones de Windows universal, Visual Studio 2015
compartió proyectos están disponibles para una variedad de tipos de proyectos, como WPF, Windows Forms, Windows Store, Windows Phone, y
bibliotecas portátiles. Con proyectos compartidos, puede escribir código C # / VB vez y compartirlo con varios proyectos en su solución, y se
puede compartir fácilmente los recursos XAML como estilos, plantillas de control y plantillas de datos, así como los activos, tales como archivos
de imagen. proyectos compartidos no son siempre la mejor solución para compartir objetos; de hecho, hay situaciones en las que es posible que
desee prefieren bibliotecas portátiles, como si se necesita crear un archivo .dll reutilizable que se dirige a un subconjunto específico de .NET. En
cualquier caso, los proyectos compartidos son sin duda una oportunidad fácil y ligero para ahorrar tiempo.
30
Capítulo 3 Código Editor Mejoras
Continuando con el mismo objetivo de Visual Studio 2013, Microsoft ha hecho, importantes mejoras adicionales a un área
fundamental de la IDE: el editor de código. Este capítulo describe las nuevas características de la llamada experiencia IDE
centrado en código, que proporciona una productividad al máximo y realmente ayuda para la escritura de alta calidad, rápido y
eficiente código.
Nota: Excepto cuando se indique explícitamente, todas las nuevas características que se describen en este capítulo se aplican a C # y
Visual Basic.
gestos táctiles
El editor de código se ha mejorado para soportar gestos comunes en pantallas táctiles. Toque ya trabajó en las versiones
anteriores, pero el IDE no se optimizó; soporte táctil sólo estaba disponible con anterioridad debido a las capacidades del
hardware. En Visual Studio 2015, puede:
• Pulse dos veces en una palabra o un identificador para seleccionarlo.
• Mantenga pulsada la tecla en la pantalla para abrir el menú contextual.
• Toque en el margen del editor de código para seleccionar la línea correspondiente del código.
• Toque y mantenga en cualquier lugar de la superficie del editor de código para desplazarse hacia arriba y hacia abajo.
• “Pinch y zoom” para acercar y alejar con dos dedos.
Va a encontrar estas características muy útiles si se utiliza Visual Studio 2015 en dispositivos táctiles como las tabletas o
portátiles.
coloreada sobre herramientas
El editor de código crea automáticamente regiones plegables para muchas construcciones del lenguaje, tales como (pero no limitado a) las
definiciones de clases, definiciones de estructuras y cuerpos de los métodos. A partir de Visual Studio 2013, cuando se derrumbó una región, puede
obtener una vista previa del código completo al pasar el puntero del ratón sobre la construcción colapsada. Visual Studio 2015 proporciona una
experiencia mejorada proporcionando información sobre herramientas coloreada y el objeto o miembro declaración completa, como se muestra en la
Figura 19.
Figura 19: Colorized información de herramientas.
31
Esto es mucho mejor si se compara con Visual Studio 2013, en el que no tiene el objeto / declaración de miembro y
el color de la descripción es solamente negro.
Bombillas y acciones rápidas
Como se puede saber, en Visual Studio 2015 y .NET Framework 4.6, los compiladores administrados han sido completamente
reescrito, lanzado como un proyecto de código abierto, y llevado a la experiencia de desarrollo de la plataforma .NET Compiler
(anteriormente conocido como Project Roslyn).
Nota: Hablando de la plataforma .NET compilador está fuera del alcance de este libro. Puede obtener información específica y
aprender cómo crear analizadores de código personalizado en Roslyn .
Entre los otros beneficios, los compiladores exponer las API, tiene incluso una mejor integración con el editor de código y el resto de la IDE, y
proporcionar, en tiempo real completo, análisis de código estático para encontrar problemas y proporcionar sugerencias a medida que escribe. centro de
mejoras principalmente en código redundante, encontrar y corregir los errores a medida que escribe, y el código de refactorización.
Cuando Visual Studio 2015 detecta código redundante, errores, o código que debe ser rediseñado, que muestra la bombilla. La
bombilla es un contenedor de acciones, denominadas Acciones rápidas, que usted puede tomar para resolver un problema
particular. La figura 20 muestra un ejemplo de la bombilla y las acciones disponibles cuando se invoca un método que no se ha
declarado en el código.
Figura 20: La bombilla proporciona acciones rápidas para sugerir correcciones de errores o refactorizar su código.
32
Por lo general, la bombilla aparece automáticamente cuando se coloca el cursor sobre un trozo de código que necesita algunas
correcciones o cuando se pasa sobre garabatos de error; Sin embargo, puede activar manualmente la bombilla presionando CTRL +
<Período>. Tienes sólo una breve introducción sobre la bombilla y acciones rápidas, pero en los siguientes párrafos, aprenderá más
sobre esta nueva característica de gran alcance.
Encontrar y corregir código redundante
análisis de código estático en vivo es capaz de detectar código redundante como no utilizada utilizando (directivas Las importaciones para las
invocaciones Visual Basic) o innecesarios de objetos. código redundante está atenuado de manera que se puede ver fácilmente en su código. La
figura 21 muestra un ejemplo de código redundante, hecho de no utilizada utilizando directivas y de la esta invocación objeto.
Figura 21: detección de código redundante.
Si hace clic en una de las utilizando directivas, aparece la bombilla. Pueden ampliar y ver cómo Visual Studio sugiere una
acción rápida para la eliminación de directivas innecesarias resaltando en rojo el código que será retirado (ver Figura 22).
33
Figura 22: la bombilla de luz sugiere la eliminación de código innecesario.
También puede aplicar estos cambios al proyecto actual o para toda la solución, no sólo el archivo de código actual. Como también
se puede ver, usted tiene la opción de vista previa de los cambios. Esto se explica con más detalle en el siguiente párrafo. Por
ahora, haga clic en el Retire Uso innecesario
sugerencias y ver cómo el IDE elimina la redundancia utilizando directivas. También puede repetir los mismos pasos en el esta
objeto.
Consejo: La opción para la eliminación innecesaria usando también está disponible haciendo clic derecho en el editor de código, la
navegación de sindicación usings, y seleccionando Eliminar usings innecesarios. En Visual Basic, la misma opción está disponible en
Organizar importaciones> Eliminar Las importaciones innecesarias.
la fijación de errores
Vivir análisis de código estático y las bombillas que sea más fácil detectar y corregir los errores a medida que escribe. Por ejemplo, considere la
definición de clase se muestra en la Figura 23.
34
Figura 23: Una clase de muestra con errores.
El código tiene varios errores, ya que le falta una utilizando System.ComponentModel Directiva y la clase en realidad
no poner en práctica el INotifyPropertyChanged interfaz, como se destaca por el garabato error.
Consejo: En Visual Studio 2015, ya no es necesario colocar el cursor fuera de una línea de código para obtener garabatos de error. De
hecho, el nuevo análisis de código estático en vivo se mostrará inmediatamente.
Puede utilizar la bombilla para corregir los errores. En este caso, la primera bombilla sugiere acciones rápidas para resolver el INotifyPropertyChanged
interfaz, como se muestra en la Figura 24.
35
Figura 24: Quick Acciones para un espacio de nombres que falta.
Una información sobre herramientas proporciona una descripción detallada sobre el mensaje de error y muestra una vista previa de los cambios en el
código cuando se pasa sobre una de las acciones rápidas sugeridas. Una buena opción en este momento es la adición de una utilizando directiva;
seleccione la primera solución para hacerlo. En este punto, el compilador detecta que la clase no está implementando la interfaz, sin embargo, por lo que la
bombilla proporciona rápidas acciones específicas para corregir este error, como se demuestra en la Figura 25.
Figura 25: Quick Acciones para una interfaz no implementado.
36
Suponga que desea implementar la interfaz implícita; seleccionar la primera solución ( Implementar interfaz) y en la vista previa, haga clic en
el Vista previa de cambios hiperenlace. En este punto, el Los cambios de previsualización Aparece el diálogo, mostrando uno o más
archivos de código en el que se va a aplicar el cambio y una vista previa completa del código con los cambios. Estos cambios se resaltan de
manera que se puede tener de inmediato una mirada, como se demuestra en la Figura 26.
Figura 26: Vista previa de cambios antes de hacer modificaciones.
Si estás bien con los cambios, simplemente haga clic Aplicar o, si se desea elegir una acción rápida diferente, haga clic Cancelar. Los
compiladores son lo suficientemente inteligentes como para sugerir soluciones adicionales basadas en el objeto que se va a utilizar. Por
ejemplo, si desea que un objeto para implementar el
IDisposable interfaz, la bombilla se mostrará acciones rápidas adicionales específicos para el patrón Dispose, como se representa en
la Figura 27.
Figura 27: Acciones rápidas que sugieren diferentes maneras de implementar un patrón.
Bombillas y acciones rápidas son muy poderosos, no sólo porque ayudan a corregir errores de forma rápida, sino también
porque suelen proporcionar las soluciones más adecuadas para el contexto actual.
37
La aplicación de Refactorizaciones
Refactoring es una técnica para volver a escribir trozos de código de una manera más eficiente y más limpio, mientras se mantiene el
comportamiento y los resultados de código existente. Durante los años, Visual Studio ha estado ofreciendo soporte incorporado para ciertas
técnicas de refactorización para C #, mientras que los desarrolladores de Visual Basic tuvieron que utilizar extensiones IDE de terceros. En
Visual Studio 2015, refactorización se ha mejorado drásticamente en varias formas. técnicas de refactorización son ahora parte de acciones
rápidas de la bombilla; Además, se han añadido nuevas características, y, finalmente, Visual Basic tiene soporte para la refactorización. Usted
aprenderá más sobre esto en los siguientes párrafos.
Extraer método
Considere el siguiente código, que simplemente calcula el área de un círculo, dado el radio.
hoyo estatico Principal( cuerda [] Args) {
doble radio = 4;
doble circleArea = radio * radio * Mates .PI;
Consola .WriteLine (circleArea);
Consola .ReadLine ();
}
La operación matemática que sucede dentro de un método, pero sería útil para separar la lógica y hacer que el código
reutilizable. Si selecciona las dos primeras líneas del cuerpo del método y habilita la bombilla presionando CTRL + <Período>,
verá una opción llamada Extraer método, como se muestra en la Figura 28.
Figura 28: Acciones rápidas que sugieren para extraer un nuevo método.
38
Como de costumbre, obtendrá una vista previa de los cambios en línea y puede hacer clic en el Los cambios de previsualización
hipervínculo para una vista más detallada. Si hace clic Extraer método, Visual Studio cambiará su código a la siguiente:
doble circleArea = newMethod ();

Consola .WriteLine (circleArea);
}
privado estática doble Nuevo método() {
doble radio = 4;
regreso circleArea;
No sólo el código está organizado mejor, pero también el nuevo método es reutilizable. Por supuesto, la mejor opción sería la de
hacer que el nuevo método acepta un argumento y usar esto en vez de codificar el radio valor variable. Cuando se genera el nuevo
método, se puede sustituir el nombre por defecto-verde resaltado; esto se logra a través de una nueva característica llamada Cambiar
nombre en línea,
que merece alguna información más detallada.
Consejo: En C #, Extraer método refactorización está disponible en el menú de contexto bajo el Refactorizaciones.
Cambiar nombre inline
Una de las tareas más comunes, mientras que la escritura de código es cambiar el nombre de identificadores, como el método o los nombres de
variables. En el pasado, usted podría simplemente haga clic en el identificador, selecciona Rebautizar, y cambiar el nombre del identificador dentro
de un cuadro de diálogo modal. En C #, también puede hacerlo pulsando Ctrl + R para cambiar el nombre de la variable o método se encuentra el
cursor. Esta característica se ha rediseñado por completo en Visual Studio 2015: al hacer clic en un identificador y seleccionar Rebautizar, puede
cambiar el nombre directamente en el editor de código y los cambios se reflejan a todas las otras apariciones del identificador. Con este enfoque,
nunca se pierde el foco en su código. Además, puede renombrar automáticamente los sucesos dentro de los comentarios y en los literales de
cadena. Continuando con el ejemplo anterior basado en el Método de refactorización Extract, la figura 29 muestra la forma en Visual Studio 2015
permite cambiar el nombre de un método recién generado.
39
Figura 29: Cambio de nombre de un objeto con el nuevo Inline Cambiar nombre.
Una ventana no modal en la esquina superior derecha muestra el número de apariciones del identificador del IDE encontró y el número total de
archivos de código que contienen el identificador. Para cambiar el nombre de un objeto, simplemente escriba el nombre nuevo sobre una de las
ocurrencias resaltadas. Los cambios se reflejarán inmediatamente a todas las otras ocurrencias. Si está satisfecho con los cambios, haga clic Aplicar,
de lo contrario sólo cerrar la ventana emergente o pulse ESC. Nota que todavía se pueden ver los cambios como lo hizo con la hora de fijar los
errores (ver el la fijación de errores anteriormente en este capítulo). La buena noticia es que se puede cambiar el nombre de forma automática
ocurrencias dentro comentarios y literales de cadena. La Figura 30 muestra el mismo código ampliado con un comentario y una cadena literal
dentro de una
Console.WriteLine declaración.
40
Figura 30: Cambiar nombre de línea puede reemplazar ocurrencias dentro comentarios y literales de cadena.
Si selecciona tanto el incluir comentarios y incluir cadenas opción en el Rebautizar caja, se verá cómo las apariciones del
identificador en los comentarios y literales de cadena se seleccionan automáticamente. Si escribe un nuevo nombre y haga clic Aplicar, todas
las ocurrencias serán sustituidos, como se demuestra en la Figura 31 que muestra cómo el Nuevo método identificador ha sido
cambiado de nombre en
CalculateCircleArea.
Figura 31: Todos los casos de un identificador renombrado con Inline Cambiar nombre.
41
Cambiar nombre en línea es otra característica útil que le ayudará a ahorrar mucho tiempo al refactorizar su código.
Introducir constante y constante introducir local
El Introducir constante e introducir técnicas de refactorización Constant locales permiten sustitución de los valores codificados de forma rígida
con constantes; estos pueden ser a nivel de clase o dentro de cuerpos de métodos. Por ejemplo, considere el siguiente código.
clase Programa
{
doble circleArea = CalculateCircleArea (4,2); }
privado estática doble CalculateCircleArea ( doble radio) {

regreso circleArea; }}
Este es un código muy simple: la CalculateCircleArea procedimiento vuelve a la persona que llama el área de un círculo, dado el
radio, que se pasa como argumento. los Principal llama al método
CalculateCircleArea pasando un valor. Si ahora selecciona 4.2 y permitir la Bombilla, verá cuatro opciones:
1. Introducir constante de '4,2',

2. Introducir constante para todas las ocurrencias de '4,2' (véase la Figura 32)
3. Introducir constante local para '4.2'
4. Introducir constante local para todas las apariciones de '4,2' (véase la Figura 33)
42
Figura 32: Presentación de una constante en el nivel de clase.
Figura 33: Presentación de una constante local en el cuerpo del método.
Las dos primeras opciones presentarán una declaración constante en el nivel de clase, la asignación de 4,2 como el valor; En
particular, la segunda opción hará lo mismo para todas las ocurrencias (si cualquier otra) de 4,2 en el código. La otra opción en su
lugar introducir un constante local en el cuerpo del método, para la ocurrencia actual o para todas las ocurrencias respectivamente.
Sea cual sea la opción que elija, Visual Studio aplicará el cambio y permitirá Cambiar nombre inline para darle la oportunidad de
elegir un identificador diferente, como se representa en la Figura 34, que muestra tanto la constante aplicada y la Cambiar nombre
Inline en acción.
43
Figura 34: Aplicación y cambiar el nombre de una constante.
Inline variable temporal
Inline variable temporal es una nueva técnica que permite la simplificación de refactorización su código mediante la eliminación de las
declaraciones de variables innecesarias. Para entender cómo funciona, considere la
CalculateCircleArea método descrito en el párrafo anterior. Si selecciona la
circleArea variable en el cuerpo del método y a continuación, habilitar la bombilla, Visual Studio mostrarán una solución simplificada,
tal como se representa en la Figura 35.
Figura 35: Inline variable temporal.
En la vista previa, pone de relieve Visual Studio en rojo el código actual y luego muestra el nuevo resultado a continuación. La aplicación de esta
acción rápida se traduce en el siguiente código.
privado estática doble CalculateCircleArea ( doble radio) {
44
regreso radio * radio * Mates .PI;
}
Este código es ciertamente más simple y más fácil de leer.
introducir local
Introducir local es una nueva técnica de refactorización que simplifica expresiones complejas mediante la introducción de
variables locales. Como ejemplo, considere el siguiente código.
privado estático doble CalculateCircleArea ( objeto radio) {
doble circleArea =
Convertir .ToDouble (radio) * Convertir .ToDouble (radio) * Mates .PI;
regreso circleArea; }
Esta nueva versión de la CalculateCircleArea método toma un argumento de tipo objeto, y a continuación, realiza la misma conversión dos
veces. Con Introducir local, definitivamente se puede mejorar este código. Seleccionar Convert.ToDouble (radio) y luego permitir que la
bombilla. Usted recibirá dos acciones rápidos: la primera permite la introducción de una variable local para el código seleccionado,
mientras que el segundo permite la introducción de una variable local para todas las demás apariciones del código seleccionado (véase la
Figura 36).
Figura 36: Presentación de una variable local para simplificar el código.
45
Cuando se aplican los cambios, en línea Cambiar nombre sigue apareciendo de manera que se puede elegir un identificador diferente para la variable
local. La aplicación de la segunda acción rápida dará como resultado el siguiente código.
privado estático doble CalculateCircleArea ( objeto radio) {
var v = Convertir .ToDouble (radio);

doble circleArea = v * v * Mates .PI;
regreso circleArea;
Como se puede ver, el código es ahora mucho más simple y más fácil de leer. Normalmente, se utiliza Introducir local para separar
expresiones complejas que están anidados en otras expresiones.
Visual Basic Support
Por primera vez en la historia de Visual Studio, el apoyo refactorización se ha agregado a Visual Basic. Esto significa que todas las
técnicas de refactorización descritas en este capítulo están disponibles para VB, incluyendo acciones rápidas para los errores de fijación
y código redundante. Como ejemplos, la figura 37 muestra cómo se puede extraer un método y La figura 38 muestra cómo se puede
introducir una variable temporal inline.
Figura 37: el apoyo de Visual Basic para refactorización: la extracción de un método.
46
Figura 38: el apoyo de Visual Basic para refactorización: la introducción de una variable temporal inline.
Este capítulo introduce algunas nuevas características clave en el editor de código. Usted se reunió información sobre herramientas tintadas, que
muestran vistas previas de las regiones frías de código contraído. Que ha aprendido cómo se puede interactuar con éxito con el editor de código en
dispositivos de pantalla táctil. Lo más importante es que ha aprendido acerca de las bombillas y acciones rápidas, lo que ayudará a solucionar los
errores al escribir y escribir mejor código con nuevas y mejoradas opciones de refactorización, ahora disponibles para Visual Basic también.
47
Capítulo 4 XAML Editor Mejoras
Muchas plataformas de desarrollo importantes se basan en el lenguaje de marcado XAML, incluyendo Windows Presentation
Foundation, aplicaciones de Windows Store, y aplicaciones de Windows Phone. Por lo tanto, XAML juega un papel clave para miles de
desarrolladores. Además, a pesar de la disponibilidad de herramientas especializadas de diseño, redacción, edición y ajuste de código
XAML es manualmente una tarea muy común. Debido a esto, Microsoft sigue invirtiendo para mejorar el editor de código XAML en
Visual Studio; versión 2015 trae nuevas golosinas que definitivamente amor, sobre todo si tiene que editar partes de la interfaz de
usuario.
Definición vistazo en el Editor de código XAML
¿Recuerdas la ojeada Definición? Hablé acerca de esta característica increíble en mi libro Visual Studio 2013 Sucintamente, que
describe cómo se puede mostrar y editar piezas de código C # o Visual Basic dentro de una ventana emergente interactivo que
aparece en el contexto de su código. Visual Studio 2015 da un paso importante al traer más Peek definición para el editor de
código XAML.
Nota: En este capítulo, voy a mencionar varios conceptos relacionados con XAML, tales como diccionarios de recursos,
estilos y plantillas de control. Asumo que está familiarizado con los conceptos y con XAML en general. Si no es así,
consulte la documentación de MSDN .
Esta es una adición importante, porque hace que sea más fácil para editar estilos, plantillas de control y plantillas de datos que residen en
los diccionarios de recursos externos del contexto de su uso. Para entender cómo el editor de código XAML puede ayudar a ahorrar
tiempo, cree un nuevo proyecto de WPF. Por supuesto, las técnicas descritas en este capítulo funcionan bien con otros entornos, tales
como aplicaciones de Windows Store y las aplicaciones de Windows Phone, no sólo WPF. Cuando el nuevo proyecto está listo, añadir un
nuevo diccionario de recursos. Ya has aprendido en el capítulo 2 cómo añadir diccionarios de recursos a un proyecto de WPF, así que no
voy a describir esto de nuevo. Supongamos que se desea proporcionar una plantilla de control personalizado para el Botón controlar. El
código siguiente muestra cómo definir una plantilla de control que representa botones con una elipse, y donde cada estado (normal,
puntero del ratón sobre, presionado) es interceptada con una Desencadenar y representado por un gradiente de fondo diferente, a través de
LinearGradientBrush objetos.
< ResourceDictionary
xmlns : local = "CLR-espacio de nombres: WpfApplication1">
< Estilo X : Llave = "ButtonStyle1" Tipo de objetivo = "Button">

< Setter Propiedad = "Plantilla">
< Setter.Value > < ControlTemplate Tipo de objetivo = "Button">
48
< Cuadrícula > < Elipse X : Nombre = "Elipse" Carrera = "Negro">
< Ellipse.Fill > < LinearGradientBrush
EndPoint = "0.5,1" Punto de partida = "0.5,0">

< GradientStop Color = "DarkBlue"
Compensar = "0" /> < GradientStop Color =
"Violeta"
Compensar = "1" /> </ LinearGradientBrush
>
</ Ellipse.Fill >
</ Elipse > < ContentPresenter
Alineación horizontal = "{ TemplateBinding HorizontalContentAlignment }"
Alineamiento vertical = "{ TemplateBinding VerticalContentAlignment }"
SnapsToDevicePixels = "{ TemplateBinding SnapsToDevicePixels }"

RecognizesAccessKey = "True" />
</ Cuadrícula > < ControlTemplate.Triggers > < Desencadenar Propiedad =
"IsMouseOver" Valor = "True">
< Setter Propiedad = "Relleno"

TargetName = "Elipse"> < Setter.Value
> < LinearGradientBrush
EndPoint = "0.5,1"
Punto de partida = "0.5,0">
< GradientStop Color = "Violeta"
"DarkBlue"
Compensar = "1" /> </ LinearGradientBrush
>
</ Setter.Value >
</ Setter >
</ Desencadenar > < Desencadenar Propiedad = "IsPressed" Valor = "True">
< Setter Propiedad = "Relleno"

TargetName = "Elipse"> < Setter.Value
> < LinearGradientBrush
EndPoint = "0.5,1"
Punto de partida = "0.5,0">
< GradientStop Color = "# FF290664"
Compensar = "0" /> < GradientStop Color = "#
FF290664"
"Violeta"
Compensar = "0,483" />
49
</ LinearGradientBrush >
</ Setter.Value >
</ Setter >
</ Desencadenar > < Desencadenar Propiedad = "IsEnabled" Valor = "False"
/> </ ControlTemplate.Triggers >
</ ControlTemplate >

</ Setter.Value >
</ Setter >
</ Estilo >
Antes de poder utilizar los recursos de un diccionario, debe decirle a la aplicación lo que los diccionarios que va a utilizar y dónde
están ubicados. Esto se logra en el App.xaml (o Application.xaml en otros tipos de proyectos) de archivos, más concretamente,
se utiliza una colección llamada
ResourceDictionary.MergedDictionaries que recoge los diccionarios necesarios.
< Application.Resources > < ResourceDictionary > < ResourceDictionary.MergedDictionaries > < ResourceDictionary
Fuente = "/ Dictionary1.xaml" /> </ ResourceDictionary.MergedDictionaries >

</ Application.Resources >
Ahora puede utilizar los recursos proporcionados por el diccionario de recursos en sus elementos de interfaz de usuario. Por ejemplo, en la
ventana principal de su proyecto se puede dibujar un botón y aplicar la costumbre
ButtonStyle1 Me gusta esto.
< Cuadrícula > < Botón Anchura = "120" Altura = "120" Contenido = "Haga clic en mí!"
Estilo = "{ StaticResource ButtonStyle1 }"/>
</ Cuadrícula >
Consejo: IntelliSense le ayudará a asignar un recurso apropiado en función del elemento de interfaz de usuario que se está trabajando.
Por ejemplo, si usted tiene estilos para los botones y para los cuadros de texto, IntelliSense mostrará sólo los estilos para los botones.
Esto ha sido introducida en Visual Studio 2013 y es particularmente útil cuando se tiene docenas de estilos o plantillas.
El resultado de esta asignación es inmediatamente visible en el diseñador, donde aparece un botón de color elíptica. Ahora puede
hacer clic derecho sobre el ButtonStyle1 identificador y seleccione Definición Peek en el menú emergente. La figura 39 muestra
cómo aparece el editor de código en este punto.
50
Figura 39: Definición Peek en el editor de código XAML.
Como se puede ver, un editor emergente conveniente aparece y le permite editar la plantilla de control en el contexto de su uso. El
emergente es interactivo, lo que significa que puede cambiar el código directamente, sin la necesidad de abrir una ventana externa que
apunta al archivo especificado. El diseñador refleja inmediatamente los cambios que realice en la ventana de la Definición de la ojeada.
Cuando haya terminado, puede simplemente cerrar la ventana emergente de la forma habitual. Esta característica funciona en el editor
XAML exactamente igual que para C # y Visual Basic. También puede invocar la ojeada definición contra código administrado. Por
ejemplo, si tiene una Hacer clic controlador de eventos para el botón, clic derecho sobre el nombre del controlador de eventos en el editor
XAML y seleccionando la ojeada Definición hará que Visual Studio para abrir la ventana peek en el código C # / VB para el controlador de
eventos.
Consideraciones adicionales para Peek Definición En XAML
Definición Peek no funciona con diccionarios de recursos sólo; también funciona con los estilos y las plantillas se define en otra
parte de su solución. Se le permite editar rápidamente estilos, plantillas, plantillas de control de datos, y cualquier otro elemento
definible como un recurso. Esta característica resulta muy útil con aplicaciones del mundo real en el que pueda tener docenas de
diccionarios y recursos, con muchos de ellos grabarán en las librerías externas. Sin lugar a dudas, que ayuda a ahorrar tiempo,
ya que evita la necesidad de buscar la definición de recursos, la apertura de los recursos dentro de una ventana de editor
externo, realizar los cambios, y luego volver al contexto de recursos de uso.
51
Puesto que es común a editar el código XAML manualmente, Visual Studio 2015 trae Peek Definición en el editor de código XAML. Esta
característica permite a los desarrolladores para modificar el estilo, plantillas, plantillas de control de datos, y cualquier otro tipo de sitio
directamente desde el contexto de uso, con ediciones reflejan inmediatamente en la superficie de diseño.
52
Capítulo 5 personalizaciones IDE: Ventana
Diseño
Visual Studio ha estado ofreciendo un gran número de formas de personalizar el entorno de desarrollo durante muchos años. Esto incluye
las barras de herramientas, ajustes, comandos de menú del editor de código, y otras partes del espacio de trabajo. Después de todo,
como desarrollador, pasas tanto tiempo en Visual Studio y por lo que debe ser capaz de ajustar el medio ambiente de acuerdo a sus
preferencias y necesidades personales. Visual Studio 2015 introduce una nueva personalización llamada ventana Diseño personalizado,
lo que hace que sea más fácil de organizar su espacio de trabajo.
Ventana Diseño personalizado
Visual Studio 2015, al igual que sus predecesores, tiene muchas ventanas de herramientas que se pueden organizar en el espacio de trabajo e
incluso pueden anclar a los cuatro lados del entorno de desarrollo. Explorador de soluciones, Caja de herramientas, lista de errores, y las
propiedades son todos ejemplos de ventanas de herramientas relacionadas. Por lo general, organizar su espacio de trabajo de acuerdo con el tipo
de proyecto que se está trabajando. Sin embargo, cuando se cambia a otro tipo de proyectos, es probable que utilizar diferentes ventanas de
herramientas y reorganizar su espacio de trabajo. El cambio entre diferentes tipos de proyectos, y en consecuencia a diferentes diseños de
ventana, a continuación, requerirían a reorganizar manualmente todas las ventanas de herramientas necesarias. Además, si se trabaja con Visual
Studio en varias máquinas, usted tiene que arreglar su diseño de ventana en cada instalación. Para hacer la vida más fácil, Visual Studio 2015
introduce una nueva forma de personalizar su espacio de trabajo, llamada ventana Diseño personalizado. Esta nueva característica permite
guardar, administrar, volver a aplicar, y la itinerancia sus diseños de ventana con las herramientas convenientes.
Distribución de ahorro de ventana
Para entender cómo funciona Ventana de diseño personalizado, supongamos primero que tiene ventanas de herramientas específicas abiertas cuando se
trabaja en un proyecto de WPF para Windows. La Figura 40 proporciona un ejemplo donde se puede ver la caja de herramientas, esquema del documento, el
Explorador de soluciones, y las propiedades de las ventanas de herramientas.
53
Figura 40: Un diseño de la ventana de muestras para proyectos de WPF.
Supongamos ahora tiene que cambiar el tipo de proyecto, el cambio a un proyecto web para la plataforma Azure. Tendrá que abrir
completamente diferentes ventanas de herramientas, lo que significa perder el diseño actual ahora y para el futuro trabajo en el proyecto.
Visual Studio 2015 proporciona ahora una oportunidad fácil de guardar y restaurar los diseños de ventana. los Ventana menú ofrece un
nuevo comando llamado Guardar Disposición de la ventana. Esto abrirá el Guardar la ventana de diálogo, donde se puede introducir un
nombre para el diseño actual, como se muestra en la Figura 41.
Figura 41: El suministro de un nombre para el diseño de la ventana.
En este punto, el diseño de la ventana se guardará para su posterior reutilización.
Consejo: Al iniciar sesión con su cuenta de Microsoft, diseños de ventana personalizados están sincronizados a través de todas sus
instalaciones de Visual Studio 2015. Esto significa que puede ejecutar Visual Studio 2015 en un equipo diferente y encontrar todos los
diseños guardados.
54
La aplicación de la ventana Presentaciones
Imagine que, después de trabajar en un proyecto de WPF, es necesario cambiar a un proyecto para la plataforma Azure, por ejemplo, un proyecto de
servicio móvil. Definitivamente va a utilizar diferentes ventanas de herramientas tales como el Explorador de servidores, el Explorador de objetos de
SQL Server, y la lista de tareas HDInsight. La figura 42 muestra un ejemplo de diseño de ventana para este tipo de proyecto, pero sus preferencias
efectivas podría ser diferente.
Figura 42: El uso de otro diseño de la ventana para un tipo de proyecto diferente.
Puede guardar el diseño actual de la ventana como se vio en el párrafo anterior, pero la consideración más importante
viene cuando vuelva a trabajar en su proyecto de WPF. Para una mejor comprensión, cierre el proyecto Azure y abrir un
proyecto nuevo o existente WPF. los Ventana
menú proporciona un comando llamado Aplicar Disposición de la ventana, que permite la selección de un diseño de ventana diferente entre una
lista de diseños guardados, como en la Figura 43 demuestra.
55
Figura 43: Aplicación de diseños de ventana.
Cuando se elige uno de la lista, Visual Studio 2015 le pedirá una confirmación antes de aplicar un diseño diferente. En este punto,
usted recibirá su área de trabajo original restaurada, que muestra todas las ventanas de herramientas necesarias para trabajar con
WPF.
Nota: Visual Studio 2015 será capaz de restaurar completamente un diseño de ventana sólo si el tipo de proyecto actual es
compatible con todas las ventanas de herramientas en el diseño. Por ejemplo, en el ejemplo actual, si se intenta aplicar la
disposición WPF cuando el proyecto de Azure sigue abierta, no se restaurará la ventana de herramientas Esquema del
documento, ya que no es compatible con un proyecto de Azure. De manera más general, que no es compatible con soluciones
diferentes de XAMLbased queridos. Esta es la razón por la que primero debe abrir un proyecto específico y luego aplicar un
diseño.
La gestión de ventanas diseños personalizados
Visual Studio 2015 también proporciona una manera fácil de manejar sus diseños de ventana personalizados. El comando Administrar diseños de
ventana en el menú Ventana que se abre el cuadro de diálogo Gestionar presentaciones de ventana (ver Figura 44), donde usted será capaz de
eliminar diseños, cambiar el nombre de los diseños, diseños y mover en la lista.
56
Figura 44: Administración de diseños de ventana.
Restaurando el diseño predeterminado
Visual Studio 2015 se suministra con una ventana estándar. Restaurar el diseño predeterminado mediante el
Restablecer Disposición de la ventana comando en el Ventana menú. Esta opción es útil cuando se desea limpiar completamente sus
preferencias ambiente y volver a aplicar diseños guardados.
Ventana de diseño personalizado en Visual Studio 2015 proporciona una nueva forma de personalizar el IDE por el ahorro, la gestión, y la
restauración de los arreglos ventana de la herramienta en el espacio de trabajo para diferentes proyectos. Esta característica le ayuda a
mantener un entorno de desarrollo muy bien organizado.
57
Capítulo 6 Lista de errores y Revisited
Las mejoras de depuración
Descubrir y corregir errores es tan importante como la escritura de código. Visual Studio siempre ha ofrecido sofisticadas herramientas de
depuración; la ventana Lista de errores es un gran compañero para examinar los errores al escribir o compilar código. El diagnóstico y
depuración de errores es un área que Microsoft mejora el utillaje para con cada nueva versión del IDE. En este capítulo se describe la
ventana Lista de errores en su nuevo aspecto, y se introduce una mejor depuración y herramientas de diagnóstico que le ayudarán a
resolver problemas de una manera más productiva.
La lista de errores Revisited
La ventana de herramientas Lista de errores muestra la lista de errores en tiempo de compilación que Visual Studio detecta al escribir
código o al compilar su solución. En Visual Studio 2015, la lista de errores ha sido revisado y ahora ofrece características útiles
adicionales.
Consejo: La ventana Lista de errores debería abrirse automáticamente cuando los compiladores algún error. Sin embargo, puede
abrirlo en cualquier momento seleccionando Ver> Lista de errores o presionando CTRL + \, E.
El límite de 100 mensajes se ha eliminado y ahora la ventana muestra la lista completa de errores. Para entender las otras nuevas
características, considerar en primer lugar el código representado en la Figura 45 y la Figura 46, que contiene algunos errores en diferentes
archivos de código. La razón por la cual los errores se ejemplifican en dos archivos diferentes será claro en breve.
58
Figura 45: Simulación de algunos errores de la Parte 1.
Figura 46: Simulación de algunos errores de la Parte 2.
Centrarse en la Lista de errores; La Figura 47 muestra una vista ampliada en este punto.
59
Figura 47: Una vista más específico de la ventana Lista de errores.
Lo primero que notará es un código de error para cada mensaje. Tal un código de error representa un error del compilador específico;
Empieza con CS si se eleva por el compilador de C # o con antes de Cristo si se eleva por el compilador de Visual Basic.
Nota: Los códigos de error adicionales se pueden mostrar si se instala (o crear) otros analizadores, como el análisis de código
para Azure se describe en el capítulo 8.
Los códigos de error se presentan en forma de hipervínculos, por lo que si hace clic en cualquier código de error, Visual Studio 2015 se abrirá el
navegador web por defecto y se buscar en Internet con Bing para encontrar información tanto sobre el código de error y el mensaje de error. Otra
nueva característica es filtros. Es, básicamente, puede filtrar la lista de error por las siguientes columnas: código, proyecto y archivo. Por ejemplo,
supongamos que desea ver los errores en solo algunos archivos específicos; haga clic en el símbolo de filtro en el Expediente
columna y seleccionar los archivos de código deseados, como se demuestra en la Figura 48.
Figura 48: Filtrado de errores por el archivo de código.
Del mismo modo, se puede filtrar la lista de errores de código de error o por proyecto; este último puede ser muy útil con soluciones de gran tamaño.
El símbolo de filtro en la esquina superior izquierda de la ventana Lista de errores proporciona formas adicionales de filtrado de la lista, como se
muestra en la Figura 49. Con esta opción, puede navegar por los errores del documento actual, para todos los documentos abiertos, o para el actual
proyecto, que es también el filtro predeterminado.
60
Figura 49: Visualización de errores sólo en el documento actual.
También puede filtrar la lista introduciendo frases en el cuadro de búsqueda, sino que se introdujo en Visual Studio 2013.
Las mejoras de depuración
La depuración es más eficiente cuando se tiene las herramientas adecuadas. Microsoft siempre ha prestado especial atención a ofrecer
herramientas de depuración sofisticados y avanzados, y Visual Studio 2015 no es una excepción. En este capítulo se describe lo que hay de
nuevo en la experiencia de depuración con Visual Studio
2015.
Soporte para Expresiones Lambda Depuración
Visual Studio 2015 introduce soporte para la depuración de las expresiones lambda. La comunidad pidió esta característica tan
fuerte que Microsoft ha trabajado duro para que esté disponible en la nueva versión del IDE. Esta característica permite el uso de
la Reloj y Inmediato ventanas para evaluar expresiones lambda; sino que también le permite entrar en el código de una expresión
lambda con comandos de depuración adecuados, tales como Paso a paso (F11). Para entender cómo funciona, considere el
siguiente código.
clase Programa
{
Lista < cuerda => Nombres nuevo Lista < cuerda > (); Names.Add ( "Alessandro"
); Names.Add ( "Renato" ); Names.Add ( "Antonio" ); Names.Add ( "Diego"
);
depurador .Rotura();
}}
61
El ejemplo de código es una simple colección de cadenas que contiene algunos nombres. Si se ejecuta el código, la ejecución rompe en Debugger.Break
() ;. Haga clic con el nombres variable y seleccione Agregar inspección. En este punto, el Reloj ventana de depuración se abre y una
instancia del objeto seleccionado está disponible para su evaluación. La buena noticia es que puede escribir una expresión lambda sobre
la instancia del objeto y evaluarla para descubrir si funciona como se esperaba. La figura 50 muestra un ejemplo donde una expresión
lambda extrae todos los nombres que comienzan con “A.”
Figura 50: Depuración de una expresión lambda.
IntelliSense también trabajará a medida que escribe, lo que hace que escribir un lambda dentro de la ventana de inspección una tarea muy fácil. No
se limita a esto, también se puede escribir consultas LINQ contra orígenes de datos compatibles, como objetos .NET, Modelos de entidad de datos,
LINQ a SQL, y así sucesivamente. La Figura 51 proporciona un ejemplo basado en el código anterior.
Figura 51: Depuración de una consulta LINQ.
Del mismo modo, se puede evaluar expresiones en el Ventana inmediata, ambos lambdas y consultas LINQ, como se muestra en la
Figura 52.
62
Figura 52: Evaluación de lambdas y consultas LINQ en la ventana Inmediato.
La mayoría de los desarrolladores les encantará esta nueva característica, ya que ahorra tiempo cuando se necesita para depurar este tipo de expresiones.
Visualización de información sobre herramientas de rendimiento: PerfTips
Visual Studio 2015 introduce una nueva característica llamada PerfTips (Rendimiento Información de herramientas), que muestra el
tiempo que se tarda en ejecutar una pieza específica de código durante la depuración. Para entender cómo funcionan PerfTips,
necesita una mejor muestra. Para ello, cree una aplicación de WPF que carga un canal RSS de Internet y luego medir el tiempo que
tarda en ejecutar código específico.
Creación de una aplicación de ejemplo
En Visual Studio 2015, cree una nueva aplicación de WPF con C # o Visual Basic. El objetivo de la aplicación de ejemplo es
para descargar la fuente RSS de la oficial Visual Studio Blog y presentar alguna información en la interfaz de usuario. Lo primero
que quiero hacer es añadir una clase que representa un solo elemento en el feed RSS; que llamamos una clase de tales Ít.
C # Código Ejemplo
público clase ít
{
público cuerda título { obtener ; conjunto ; }
público Uri enlace { obtener ; conjunto ; }
público cuerda autor { obtener ; conjunto ; }
público Sistema. Fecha y hora PubDate { obtener ; conjunto ; }}
Público Clase ít
Público Propiedad Título Como cuerda
63
Público Propiedad Enlazar Como Uri
Público Propiedad Autor Como public String Propiedad PubDate
Como fecha de finalización Clase
Como se puede ver, esto es una clase simple que almacena información como el autor del blog post, título, enlace y fecha de publicación. A
continuación hay que escribir el código XAML para la interfaz de usuario, que proporciona un botón para cancelar la operación y una Cuadro
de lista control, cuya ItemTemplate 's DataTemplate
organiza alguna Bloque de texto controla verticalmente dentro de una StackPanel envase. Bloque de texto
controles están obligados a propiedades de la ít clase.
< Ventana X : Clase = "OpenFeed.MainWindow"

Cargado = "Window_Loaded"
xmlns : mc = "Http://schemas.openxmlformats.org/markupcompatibility/2006"
xmlns : local = "CLR-espacio de nombres: OpenFeed"

mc : ignorable = "D"
Título = "MainWindow" Altura = "350" Anchura = "525"> < Cuadrícula > < Grid.RowDefinitions
> < RowDefinition Altura = "40" /> < RowDefinition /> </ Grid.RowDefinitions > < Botón
Anchura = "120" Altura = "30" Nombre = "CancelButton"
Contenido = "Cancelar" Hacer clic = "CancelButton_Click" /> < Cuadro de lista Nombre
= "ContentBox" Grid.Row = "1"
ItemsSource = "{ Unión } "> < ListBox.ItemTemplate > < DataTemplate
> < StackPanel > < Bloque de texto Texto = "{ Unión Título }"
Ajuste de texto = "Wrap" Tamaño de fuente = "16"

Grid.Row = "1" Etiqueta = "{ Unión Enlazar }"
Primer plano = "Blue"
FontWeight = "Bold"
MouseLeftButtonUp = "TextBlock_MouseLeftButtonUp" /> < Bloque de texto Texto

= "{ Unión PubDate ,
StringFormat = D}" Primer plano = "Red"
Grid.Row = "2" />
< Bloque de texto Texto = "{ Unión Autor }" Grid.Row = "3" /> </ StackPanel >
</ DataTemplate >

</ ListBox.ItemTemplate >
64
</ Cuadro de lista >
</ Cuadrícula >
</ Ventana >
Ahora se necesita un código que descarga el contenido del feed RSS, analiza el XML correspondiente, y llena la
interfaz de usuario con la información apropiada (ver comentarios).
Nota: Es necesario añadir una referencia a System.Net.Http.dll con el fin de utilizar la clase HttpClient.
C # Código Ejemplo
// La URL de fuente de alimentación.

const string privada FeedUri =
"Http://blogs.msdn.com/b/visualstudio/rss.aspx" ;
// señal de cancelación requerido para cancelar la operación.

privado CancellationTokenSource CancellationToken;
private void CancelButton_Click ( objeto remitente, RoutedEventArgs e) {
Si ( esta .cancellationToken! = nulo ) {
//Solicitud de cancelacion.
esta .cancellationToken.Cancel ();
}}
// Abrir el mensaje seleccionado en el navegador por defecto.

private void TextBlock_MouseLeftButtonUp ( objeto remitente,
MouseButtonEventArgs mi)
{
var content = ( Bloque de texto )remitente;
var link = ( Uri ) Content.Tag;
Proceso .Start (link.AbsoluteUri);
}
vacío asincrónico privado Window_Loaded ( objeto remitente,

RoutedEventArgs mi)
{
// Crear una instancia de la señal de cancelación.
esta .cancellationToken = nuevo CancellationTokenSource ();
// Cargar y asignar datos a DataContext de la ventana.

esta .DataContext = esperar
QueryRssAsync ( esta .cancellationToken.Token);
sesenta y cinco
}
asincrónico privado Tarea < IEnumerable < ít >>

QueryRssAsync ( CancellationToken simbólico)
{
tratar
{
// Acceso a través de HTTP para los datos del canal de descarga y como una
cuerda.
var cliente = nuevo HttpClient ();
var data = esperar client.GetAsync ( nuevo Uri (FeedUri), token);
var actualData = esperar data.Content.ReadAsStringAsync ();
// Ejecuta una consulta LINQ to XML con la alimentación.

var doc = XDocument .Parse (actualData);
var dc =
XNamespace .Obtener( "Http://purl.org/dc/elements/1.1/" );
var query = ( desde entrada en (doc.Descendants "ít" )

seleccione nuevo ít
{
Title = entry.Element ( "título" ) .Value, Link = nuevo
Uri (Entry.Element ( "enlazar" ).Valor),

Author = entry.Element (dc +
"creador" ).Valor,
PubDate =
Fecha y hora .Parse (entry.Element ( "PubDate" ).Valor,
System.Globalization. CultureInfo .InvariantCulture)

});
regreso consulta; }
captura ( OperationCanceledException ) {
Buzon de mensaje .Mostrar( "Operación cancelada por el usuario" );

return null ; }
captura ( Excepción ex) {
Buzon de mensaje .Show (ex.Message);

return null ; }}
66
Las importaciones System.Net.Http

Las importaciones < xmlns: dc = " http://purl.org/dc/elements/1.1/ " >
Las importaciones System.Threading
...
Privado const FeedUri Como cuerda = _

"Http://blogs.msdn.com/b/visualstudio/rss.aspx"
'Token de cancelación requerido para cancelar la operación.

Privado CancellationToken Como CancellationTokenSource
Privado asíncrono Función QueryRssAsync (token Como CancellationToken ) Como _

Tarea ( De IEnumerable ( De ít ))
Tratar
'El acceso a través de HTTP a los datos del canal de descarga y como una cadena.
Oscuro cliente Como nuevo HttpClient
Oscuro data = Esperar client.GetAsync ( Nuevo Uri (FeedUri), token)
Oscuro actualData = Esperar data.Content.ReadAsStringAsync
'Ejecutar una consulta LINQ to XML con la alimentación.

Oscuro doc = XDocument .Parse (actualData)
Oscuro query = Desde alimentar En Doc ... < ít >

Seleccione Nuevo ít Con {
. Title = alimentación . < título > .Valor,
. Autor de alimentación = . < dc: creator > .Valor,
. link = Nuevo Uri (alimentar . < enlazar > .Valor),
. PubDate = Fecha .Parse (feed . < pubDate > .Value, globalización. CultureInfo
.InvariantCulture)}
Regreso consulta
Captura ex Como OperationCanceledException

Buzon de mensaje .Mostrar( "Operación cancelada por el usuario." )
Regreso nada de captura ex Como
Excepción
Buzon de mensaje .Show (ex.Message)
Regreso Nothing End
Try End Función
Privado Sub asíncrono MainWindow_Loaded (remitente Como objeto ,
67
mi Como RoutedEventArgs ) Me maneja .Cargado
'Crear una instancia de la señal de cancelación.
Yo .cancellationToken = Nuevo CancellationTokenSource
'Cargar y asignar los datos a DataContext de la ventana.

Yo .DataContext = Esperar QueryRssAsync ( Yo .cancellationToken.Token)
End Sub
Private Sub CancelButton_Click (remitente Como objeto , e Como RoutedEventArgs )

Si yo .cancellationToken IsNot nada entonces
'Solicitud de cancelacion.
Yo .cancellationToken.Cancel ()
End If End
Sub
'Abrir el mensaje seleccionado en el navegador por defecto.

Private Sub TextBlock_MouseLeftButtonUp (remitente Como objeto , e Como MouseButtonEventArgs
)
Oscuro content = CType (remitente, Bloque de texto )
Oscuro link = CType (Content.Tag, Uri )
Proceso .Start (link.AbsoluteUri)

End Sub
La figura 53 muestra un ejemplo de cómo se recupera y se presenta en la interfaz de usuario de los datos.
Figura 53: La descarga y la presentación de los contenidos RSS.
Depuración con PerfTips
Para entender PerfTips, coloque tres puntos de interrupción en la siguiente (ver Figura 54):
68
• La declaración de la instancia de la HttpClient clase.
• La línea que invoca XDocument.Parse.
• La línea que devuelve el resultado de la consulta.
Nota: En aras de la simplicidad, de ahora en adelante todas las cifras se basa en la versión # C de la aplicación de la muestra.
Sin embargo, los mismos conceptos, pasos y resultados se aplican a Visual Basic también.
Figura 54: Adición de puntos de interrupción.
prensa F5 para iniciar la depuración. El depurador se romperá antes de acceder a la fuente RSS. Con PerfTips ahora se puede medir el
tiempo que tarda entre la descarga de datos desde la alimentación y antes de que comience la aplicación analizar los datos descargados.
prensa F5 otra vez; cuando el depurador se encuentra con el segundo punto de interrupción, se rompe la ejecución y muestra una pequeña
pieza de información con respecto al tiempo transcurrido en milisegundos. Si se pasa sobre esa información, aparece un texto de ayuda
más detallada. La figura 55 muestra ambas características.
69
Figura 55: Medición del tiempo de ejecución de código con PerfTips.
Si ahora continuar la ejecución pulsando F5, usted será capaz de medir la ejecución de código hasta el siguiente punto de interrupción
(véase la Figura 56). En este caso particular, se puede ver el tiempo que tomó para ejecutar una consulta LINQ contra los datos del canal
descargados.
Nota: Recuerde que el tiempo transcurrido también incluye algo de sobrecarga depurador. Esto se debe a la ejecución
depurador afecta a las actuaciones de alguna manera, por lo que el tiempo transcurrido es siempre un poco más alto que el
tiempo de ejecución real.
70
Figura 56: Medición de otra pieza de código con PerfTips.
No está limitado a utilizar PerfTips con puntos de interrupción. De hecho, puede obtener información sobre el rendimiento con otras
opciones de depuración, tales como la ejecución de código línea por línea con las Entrar en presionando F11, o al desplazarse por el código
con Con el paso ( F10), Salir ( Shift + F11), o Ejecutar hasta el cursor ( CTRL + F10).
Herramientas diagnosticas
Visual Studio 2015 Enterprise Edition incluye una nueva herramienta llamada herramientas de diagnóstico, que permite analizar dónde y
cómo su aplicación consume recursos. Herramientas de diagnóstico está disponible como una ventana de herramientas que muestra
automáticamente cuando comience a depurar una aplicación. Entre los demás, se puede analizar la utilización de CPU, uso de memoria, y
los eventos del depurador. La figura 57 muestra un ejemplo de esto.
71
Figura 57: Análisis de actuaciones de aplicaciones con herramientas de diagnóstico.
La ventana de herramientas de diagnóstico tiene una línea de tiempo que se rellena con información como la ejecución de la aplicación continúa.
Muestra eventos del depurador como las excepciones y puntos de ruptura, pero también se integra con eventos IntelliTrace. También se puede
realizar el análisis de memoria avanzada seleccionando el Uso de memoria pestaña (ver la parte inferior de la Figura 57) y tomar instantáneas de
memoria. Cuando usted consigue un poco, puede hacer clic sobre el número total de objetos instanciados en un cierto tiempo para ver la lista
completa de los objetos y el número de casos está activa para cada objeto. Puede desactivar (o activar) la ventana Herramientas de diagnóstico en
cualquier momento seleccionando Herramientas> Opciones
> depuración > herramientas de diagnóstico. Además, puede abrir manualmente a través de las herramientas de diagnóstico
Depurar> Mostrar herramientas de diagnóstico. En el momento de escribir este capítulo, las herramientas de diagnóstico no es compatible con ASP.NET
5 proyectos básicos, JavaScript aplicaciones de 64 bits de Windows Store, y la depuración remota.
La gestión de puntos de interrupción con la configuración del punto de interrupción
Al colocar puntos de interrupción en las aplicaciones de ejemplo de vista previa, probablemente ha notado una pequeña barra de herramientas que
aparece cerca del glifo rojo. Esta pequeña barra de herramientas permite acceder a los ajustes de punto de interrupción con una experiencia
completamente nueva, como se muestra en la Figura 58.
Figura 58: La nueva barra de herramientas de configuración de punto de interrupción.
Esta barra de herramientas tiene un botón para desactivar los puntos de interrupción, pero, lo más importante, ofrece otro botón para la personalización de los
puntos de corte con rapidez. configuración de puntos de ruptura aparecen ahora como un no-modal, ventana mirar directamente dentro del editor de código, tal
como se representa en la Figura 59.
72
Figura 59: configuración del punto de interrupción aparecen ahora como una ventana peek.
Los ajustes se pueden editar son básicamente los mismos, pero lo que Studio 2015 Visual cambios es la forma de acceder y editar los ajustes, que
está directamente en el interior del editor de código; este es un enfoque nuevo, sin bloqueo que le permite escribir código de punto de ruptura con la
configuración abierta. Todavía se puede establecer
condiciones y Comportamiento. Condiciones de control cuando el punto de interrupción debe ser golpeado; la condición por defecto es que
el punto de corte se ve afectado cuando la ejecución de código llega a su ubicación. Las acciones de control lo que el depurador debe hacer
cuando se cumplan todas las condiciones. La acción predeterminada es que el depurador se detiene la ejecución del código. Por ejemplo, es
posible que desee detener la ejecución de la aplicación de ejemplo sólo cuando el resultado de la descarga de datos desde la fuente RSS es
nula y, si ocurre, es posible que desee enviar a la ventana de salida de la pila de llamadas. Puede utilizar una condición como la que se
muestra en la Figura 60 donde el actualData == null expresión debe ser igual a cierto. Vale la pena mencionar que va a tener IntelliSense
disponibles al escribir sus condiciones. Se puede establecer una acción invocando el $ PILA DE LLAMADAS función que se imprimirá toda la
pila de llamadas en la ventana de resultados.
73
Figura 60: las condiciones y acciones Especificación.
Consejo: Al proporcionar acciones, un IntelliSense especializado le ayudará a elegir entre las funciones disponibles y aparecerá
un describirá cada uno de ellos.
En cuanto a las condiciones, puede seleccionar uno entre expresión condicional, Cantidad de aciertos, y filtro. Como su nombre lo indica, una
expresión condicional hará que el punto de corte para ser golpeado sólo cuando la expresión especificada se evalúa como True o cuando ha
cambiado. Si por el contrario tiene iteraciones (por ejemplo,
para bucles) y desea un punto de interrupción de ser golpeado solamente en la iteración especificada, puede utilizar Cantidad de aciertos y
especificar que el número de iteración debe ser =, Múltiplo de, o> = que el valor especificado. Esto es útil cuando se descubre que se produce
un error sólo desde un cierto punto de la ejecución de la aplicación. en su lugar se puede usar filtro para especificar los dispositivos, procesos
o hilos que se ejecuta en un punto de interrupción.
Nota: Los ajustes del punto de interrupción no son diferentes de las anteriores ediciones. La diferencia está en la forma de acceder y editar
los ajustes. En este libro, nos centramos en lo que hay de nuevo en la experiencia del desarrollador, así que sería bueno para comprobar el documentación
de MSDN para más información sobre los ajustes y las condiciones disponibles.
Condiciones y acciones pueden trabajar ya sea juntos o por separado. Sin lugar a dudas, la nueva experiencia es impresionante, ya que
puede manejar fácilmente los valores de punto de interrupción sin tener que perder el foco en su código.
74
En este capítulo usted aprendió acerca de cómo la ventana de herramientas Lista de errores ha sido revisado con los códigos de error,
hipervínculos y opciones avanzadas de filtrado. A continuación, hemos visto cómo muchas inversiones se han hecho para las herramientas
de depuración, incluyendo la opción de depuración de las expresiones lambda y consultas LINQ en Mira y ventanas inmediatas; También ha
aprendido que se puede medir actuaciones de código con PerfTips y herramientas de diagnóstico y cómo controlar la configuración de punto
de ruptura con el nuevo modo no-bloqueo, no modal, y la experiencia basada en la ventana peek. Todas estas características importantes
aumentarán su productividad y sin duda ayudará a escribir mejor y con más prestaciones código.
75
Capítulo 7 Gestión de paquetes NuGet
NuGet es el gestor de paquetes para Microsoft Visual Studio. Con NuGet, puede buscar fácilmente para bibliotecas que pueda necesitar
su aplicación. El utillaje IDE para NuGet descarga automáticamente los paquetes para su solución, añade referencias, y resuelve todas
las dependencias necesarias. NuGet es también un enorme depósito de bibliotecas que puede consumir, pero también se puede publicar
sus propias bibliotecas para Nuget que otros desarrolladores puedan utilizar en sus proyectos. NuGet ha existido desde hace unos años,
comenzando como un proyecto independiente y luego convertirse en una parte fundamental de Visual Studio 2012. Para Microsoft, NuGet
es tan importante que muchas bibliotecas están disponibles sólo a través de NuGet, tales como el Marco de la entidad o de la ASP.NET 5
pila componibles. Más precisamente, en .NET Core 5 todas las bibliotecas necesarias provienen de NuGet y el IDE ya no añade
referencias a cualquier biblioteca de la. NET Framework. Visual Studio 2015 mejora el soporte para NuGet, convirtiéndolo en una
herramienta aún mejor.
Una nueva NuGet
Visual Studio 2015 ofrece una experiencia NuGet revisited. Ahora las herramientas NuGet aparecen dentro de una ventana de herramientas
acoplable con un enfoque no-modal y de no bloqueo. Para entender el nuevo NuGet, suponga que tiene un proyecto de WPF y que desea
instalar las bibliotecas de Entity Framework. En Visual Studio 2015, puede acceder a las herramientas NuGet seleccionando Herramientas >
Gestor de paquetes NuGet > Administrar paquetes NuGet de Solución o al hacer doble clic en el nombre del proyecto en
Explorador de la solución y seleccionando Administrar paquetes NuGet. La ventana NuGet aparece como se representa en la Figura
61.
Figura 61: La nueva ventana NuGet.
76
Como se puede ver, que ya no tienen un diálogo modal; En su lugar, usted es libre de cambiar entre ventanas de herramientas y las
ventanas del editor de código. El lado izquierdo de la ventana muestra la lista de paquetes disponibles, basado en el origen del paquete,
filtro, y incluir una salida prevista cajas. los origen del paquete cuadro permite seleccionar el repositorio en línea a través del cual la
búsqueda de paquetes. El valor predeterminado es nuget.org, mientras que otras opciones disponibles son Microsoft y .NET y
preview.nuget.org; Esta última opción busca específicamente para versiones preliminares. los Filtrar Caja filtra la lista de paquetes
en caso de que quiera ver Todos paquetes (valor por defecto), instalado
paquetes y paquetes con una Actualización disponible. Usted puede buscar por palabra clave paquetes a través de la Buscar caja de texto.
En el lado derecho de la ventana, se obtiene información detallada sobre el paquete seleccionado (ver Figura 61). Usted obtener información
como la descripción del paquete, autor, licencia, y el número de descargas, sino que también tiene la opción de elegir entre múltiples
versiones. Si el paquete tiene dependencias en otras bibliotecas, estos también se enumeran en la parte inferior de la ventana. También es
interesante ver cómo se puede especificar qué acción tomar en caso de conflicto de archivos ( Del sistema, haga caso de todo, Sobrescribir
todos). Cuando esté listo, simplemente haga clic Instalar.
Aceptar cualquier acuerdo de licencia requerida por el propietario del paquete y esperar unos segundos con el fin de obtener los paquetes
instalados. Si la instalación se realiza correctamente, Visual Studio muestra una casilla de verificación verde cerca del nombre del paquete, como
Figura 62: Instalación de paquetes tuvo éxito.
Consejo: A excepción de la aceptación del acuerdo de licencia, que es un cuadro de diálogo modal, la ventana NuGet nunca bloquea la interfaz de
usuario, por lo que puede cambiar a otras ventanas, incluyendo el editor de código, mientras que la instalación de paquetes.
Usted será capaz de ver los paquetes descargados en el referencias nodo para su proyecto en el Explorador de soluciones. Una
buena adición al apoyo NuGet en Visual Studio 2015 es la opción para ver un gráfico de dependencias para los paquetes. Seleccionar Herramientas
> NuGet Administrador de paquetes > Paquete visualizador para obtener una representación visual de los paquetes instalados y
sus dependencias. La figura 63 muestra un ejemplo en el que hay un proyecto principal con dos paquetes instalados y un paquete
tiene dependencias en el otro.
77
Figura 63: Paquete visualizador.
El gráfico de la dependencia se basa en la código Mapa utillaje, que se introdujo en el IDE de Visual Studio 2012 y mejorado en Visual
Studio 2013. Se hereda todas sus características, como la exportación del gráfico a la imagen, los elementos de agrupación, la elección de
diferentes colores, añadir comentarios, y así sucesivamente.
Configuración de las preferencias NuGet
La nueva ventana NuGet ha como atajo cerca de la caja de la búsqueda (véase la Figura 61) para invocar la
opciones diálogo para NuGet. Por supuesto, todavía se puede utilizar Herramientas > NuGet Administrador de paquetes > Configuración del
Administrador de paquetes para abrir la configuración NuGet. Sin lugar a dudas, la opción más interesante es que se puede especificar fuentes de
paquetes adicionales, lo que también significa que usted puede crear su repositorio basado en NuGet. La Figura 64 muestra el Fuentes de paquetes Opciones.
78
Figura 64: Opciones de fuentes de paquetes.
Aunque no se puede editar el fuentes de paquetes de todo el equipo contenido, que normalmente apunta a los paquetes de .NET
Framework, definitivamente se puede añadir fuentes personalizadas haciendo clic en el verde
+ símbolo. los Nombre y Fuente cuadros de texto se habilitarán, aceptando un nombre amigable para el repositorio y la URL. Es
importante mencionar que también se puede especificar una carpeta local en su máquina, no sólo un repositorio en línea.
Nota: En caso de estar interesado en la creación de paquetes y repositorios NuGet personalizados, la

NuGet fundación tiene documentación específica .
En este capítulo, hemos visto cómo NuGet utillaje ha sido revisada con el fin de no bloqueo en la gestión de paquetes en su
solución. También vio cómo crear gráficos de dependencia de sus paquetes y cómo especificar los ajustes adicionales. Es
importante recordar que las herramientas son en realidad NuGet ofrecidos por una extensión de Visual Studio y Microsoft
proporciona actualizaciones para esta extensión muy a menudo.
79
Capítulo 8 Visual Studio 2015 para ASP.NET
y Azure
la creación de aplicaciones para entornos web y en la nube es la actividad principal durante muchos miles de desarrolladores. A medida que
los entornos web y en la nube evolucionan continuamente y al mismo tiempo, Microsoft es consciente de que los desarrolladores necesitan
herramientas adecuadas para estar en el mercado de forma rápida y eficiente. Basado en .NET Core 5, la reciente liberación de ASP.NET 5
marca una nueva era para el desarrollo web; ASP.NET es ahora una fuente abierta plataforma capaz de ejecutarse en múltiples sistemas
operativos, como Linux y Mac OS X, y los proyectos sólo se cree utilizan las bibliotecas necesarias a través de paquetes NuGet, en lugar de
confiar en .NET Framework completo. Esto se conoce como ASP.NET cloudoptimized; que hace que sea más fácil de desplegar aplicaciones
Web en Microsoft Azure. Por otra parte, Microsoft Azure ofrece nuevas y potentes servicios y herramientas con cada actualización. Todas
estas mejoras importantes y nuevas características hacen que Visual Studio 2015, el lugar perfecto para construir aplicaciones web con
ASP.NET y Microsoft Azure. En este capítulo se explica qué hay de nuevo desde una perspectiva entorno de desarrollo para ayudarle a
aumentar su productividad.
Nota: Al explicar ASP.NET 5 y Microsoft Azure en detalle requeriría libros enteros, por lo que proporciona una guía sobre
cómo crear aplicaciones no es posible en este contexto. ASP.NET tiene una infraestructura totalmente revisado y muchas
nuevas características que hacen que un breve resumen imposible en este libro. En su lugar, aprender más en los sitios
oficiales para ASP.NET
y microsoft Azure , Incluyendo la documentación completa sobre ambas tecnologías.
Requisitos previos Capítulo
Todo lo que necesita para trabajar con ASP.NET 5 ya está incluido en Visual Studio 2015, suponiendo que haya seleccionado las
herramientas de desarrollo web entre las opciones de instalación disponibles. Con el fin de completar este capítulo, se necesita tanto de los
siguientes para Microsoft Azure:
• Una suscripción-Si Microsoft Azure usted es un suscriptor de MSDN, puede activar una suscripción Azure incluidos en
su plan; Si usted no tiene una suscripción Azure, se puede obtener una prueba gratuita durante 30 días .
• los Azure SDK para Visual Studio 2015, que se puede obtener a través de la libre Microsoft Web Platform Installer herramienta.
En la publicación, la versión actual para el SDK de Azure es 2.5.1.
Suponiendo que ha instalado todos los componentes necesarios y se activa una suscripción de Microsoft Azure, ya está listo
para descubrir las nuevas características de Visual Studio 2015.
80
Visual Studio 2015 para ASP.NET 5
Las herramientas más interesantes añaden a apoyar ASP.NET 5 en .NET Core 5 en Visual Studio 2015 son básicamente nuevas
plantillas de proyecto, un nuevo sistema de proyectos, una mejorada IntelliSense para apoyar la segmentación multi-marco, y el gerente
NuGet actualizada.
Consejo: Este capítulo no comprende la forma de gestionar los paquetes NuGet ya que se discutió en el Capítulo 7. Sólo
recuerde que el capítulo anterior se aplica a ASP.NET también.
Plantillas de proyecto Core 5 ASP.NET
Visual Studio 2015 añade cinco nuevas plantillas de proyecto para apoyar ASP.NET 5 Core. En particular, dos nuevas plantillas de
proyecto se han añadido a la Web nodo de la Nuevo proyecto diálogo; ellos son los Biblioteca de clases (paquete) y el Aplicación
de consola (paquete) ( véase la Figura 65).
Figura 65: ASP.NET 5 Biblioteca de clases y las plantillas de nuevo proyecto de aplicación de consola.
Tanto las plantillas de aplicación Biblioteca de clases y Consola producen montajes que pueden ejecutarse en múltiples plataformas
cuando se utiliza ASP.NET 5 Core. Otros tres plantillas de proyecto se han añadido a la Nuevo proyecto ASP.NET de diálogo, que
aparece cuando se selecciona la Aplicación Web ASP.NET plantilla en el Nuevo proyecto diálogo. En concreto, ahora tiene un
nuevo grupo llamado ASP.NET 5 Vista previa de plantillas, que contiene el Vacía, sitio Web, y web API plantillas de proyecto, como
81
Figura 66: ASP.NET 5 nuevas plantillas de proyecto.
Consejo: Al instalar el SDK Azure 2.5.1 o superior, otra plantilla proyecto llamado Azure Mobile App se añade a las plantillas
de ASP.NET 4.6.
Lo que la plantilla ASP.NET Web 5 de arranque hace es crear una aplicación web básica basada en
MVC 6 , Incluyendo algunos modelos de identidad, controladores, puntos de vista y soporte para migraciones de Entity Framework. La figura
67 muestra lo que sucede cuando se crea un nuevo proyecto Web de inicio. Se puede ver cómo Visual Studio 2015 proporciona una
importante lista de enlaces para aprender lo que es nuevo; también se muestra un nuevo sistema de proyecto en el Explorador de soluciones.
82
Figura 67: Creación de un proyecto Web de inicio.
Si está familiarizado con ASP.NET MVC, usted será capaz de volver a utilizar sus habilidades acerca de los modelos, vistas y controladores. Esta plantilla
de proyecto también es compatible con la API de Web para construir servicios HTTP RESTful. Las grandes diferencias en cambio se relacionan con el
nuevo sistema de proyecto.
Un nuevo sistema de proyectos
Como se puede ver mediante la expansión de todos los elementos del proyecto en el Explorador de soluciones, ASP.NET 5 proyectos básicos tienen una
nueva estructura. Este nuevo sistema de proyecto permite la separación limpia entre los archivos estáticos y archivos de código, gestión automatizada de
proyectos, y una mejor gestión de paquetes.
El Nodo wwwroot
los wwwroot nodo contiene todos los archivos de código estático, como los activos, fuentes, archivos CSS, archivos JavaScript y archivos HTML.
archivos de código, como los archivos de afeitar C # y, nunca deben ir en esta carpeta porque wwwroot proporciona una separación limpia entre los
archivos de código y archivos estáticos.
83
El nodo Dependencias
los dependencias nodo contiene dependencias para Cenador y NGP . Bower es básicamente un gestor de paquetes de cliente para la Web y
permite la instalación y restauración de paquetes del lado del cliente, incluyendo JavaScript y CSS bibliotecas. Bower funciona en el cliente,
por lo que aún va a utilizar NuGet en los marcos del lado del servidor como MVC 6. NPM es en cambio un gestor de paquetes construido
originalmente para Node.js. Visual Studio 2015 utiliza automáticamente Bower para instalar paquetes y genera una lista de paquetes en el Bower.json
archivo que se puede encontrar en el Explorador de soluciones. Puede editar manualmente Bower.json añadiendo dependencias de la dependencias
nodo. Suponiendo que desea utilizar el
RequireJS biblioteca, puede empezar a escribir y obtener ayuda de IntelliSense para elegir entre las bibliotecas disponibles, como se muestra en
la Figura 68. No se limita a esto, se obtiene compatibilidad con IntelliSense para elegir una de las versiones disponibles (ver Figura 69).
Figura 68: Edición del archivo Bower.json con el apoyo de IntelliSense.
84
Figura 69: IntelliSense ayuda a elegir una de las versiones disponibles.
Una vez que haya completado las modificaciones, haga clic en el Cenador subcarpeta en el Explorador de soluciones y seleccione Restaurar
Paquetes ( véase la Figura 70).
Figura 70: Restauración de los paquetes apropiados después de editar Bower.json.
85
En el Explorador de soluciones también verá un archivo llamado package.json, que contiene la lista de dependencias para la NGP. La
subcarpeta NPM contiene archivos específicos para JSON adicional Gruñido . Ronco es un corredor de tareas basadas en JavaScript que
ayuda a automatizar tareas rutinarias de desarrollo. El sitio web oficial de ASP.NET tiene una ejemplo interesante que muestra cómo utilizar
ronco con la plantilla de proyecto Web de inicio. un ejemplo de este tipo también se explica cómo utilizar herramental adicional específica de
Grunt, tales como el Tarea Runner Explorador ventana.
Los nuevos archivos de proyecto y archivos JSON
proyectos ASP.NET 5 Core tienen una organización diferente para los archivos y la información de configuración. En particular, las
diferencias incluyen lo siguiente:
• Los archivos de proyecto tienen la extensión. kproj extensión. El archivo de proyecto ya no contiene ningún artículo de directorio o
referencias porque Visual Studio 2015 incluye automáticamente los archivos necesarios.
• los project.json archivo contiene la lista de dependencias de referencia y las definiciones del paquete, versión,
configuraciones marco, opciones de compilación, crear eventos, creación de paquetes meta-datos y comandos. Con toda
esta información en un archivo JSON es muy útil, ya que puede ser editado manualmente en los proyectos que se
ejecutan en Linux y MacOS y que no tiene Visual Studio 2015 instalado.
• los config.json archivo se utiliza en lugar de Web.config y contiene toda la información de la aplicación y la configuración del
servidor. Por supuesto, todavía está allí Web.config para ASP.NET 4.5 proyectos.
El Nodo Referencias
El nodo de referencia muestra todos los marcos que figuran en project.json. Por defecto, seleccionados (y muestran) son
marcos 4.5.1 DNX y DNX Core 5.0. Cada marco contiene el código necesario para arrancar y ejecutar una aplicación dentro
de un entorno de ejecución de .NET, y está representado por un nodo que se puede ampliar para mostrar la lista de
paquetes por marco.
El Nodo Compilador
El nodo compilador contiene archivos de código de directivas de pre-compilación basado en el motor de la maquinilla de afeitar.
IntelliSense Mejoras
IntelliSense es otro lugar que tiene mejoras en Visual Studio 2015 para ASP.NET 5 Core. Por ejemplo, ya que puede dirigirse a
múltiples marcos, como ASP.NET 5 y ASP.NET Core 5, IntelliSense puede mezclar sugerencias para mostrar una advertencia
cuando un miembro no está soportado en un solo marco, como se demuestra en la Figura 71.
86
Figura 71: IntelliSense puede dirigirse a múltiples marcos.
No se limita a esto, la ventana Lista de errores puede mostrar errores para marcos específicos, como se demuestra en la
Figura 72, que refleja el código que se muestra en la Figura 71.
Figura 72: la lista de errores muestra errores por-marco.
IntelliSense tiene un apoyo específico para los archivos bower.json y package.json e introduce soporte para el < link rel =
"importación" /> elemento en el editor de HTML, que forma parte de la Componentes Web Estándar , Como se demuestra en la
Figura 73.
87
Figura 73: actualizaciones de IntelliSense para el editor HTML.
Visual Studio 2015 para Microsoft Azure
Al principio de este capítulo, ha sido invitado a instalar el último SDK de Microsoft Azure, que se extiende de Visual Studio
2015 para interactuar con la plataforma Azure desde el IDE. Ahora obtendrá orientación sobre las nuevas características
más relevantes que harán su vida más fácil cuando se trabaja con Azure desde Visual Studio.
Nota: En cuanto a las versiones anteriores, la corriente Azure SDK agrega no sólo muchas características a Visual Studio, pero
proporciona herramientas y servicios adicionales. En este libro nos centramos en las características que están disponibles en el IDE
de Visual Studio de 2015. Para obtener una lista completa de nuevas características, se puede leer la SDK 2.5.1 Azure para .NET
Notas de la versión . Además, este capítulo se menciona muchos servicios y plataformas que Microsoft Azure expone; en este caso,
se proporcionan enlaces a páginas oficiales y documentación, mientras que el libro se centra en los nuevos útiles.
de inicio rápido
Inicia rápidos proporcionan una colección de proyectos de la muestra, que demuestran el uso de diversos servicios de Azure y
APIs. Están disponibles en el Nube> Tutoriales nodo en el Nuevo proyecto diálogo como se demuestra en la Figura 74.
88
Figura 74: Inicia Quick proyectos para Azure.
proyectos de arranque rápido también se organizan en sub-nodos, llamados AppServices, Compute, y

Servicios de datos. Cada proyecto ofrece una muestra completamente funcional, que muestra cómo utilizar las API que son específicos para
el servicio de destino. Esto significa que el código de ejemplo contiene comentarios muy detalladas y ejemplos sobre la forma de interactuar
con el servicio deseado en el código. Por ejemplo, el listado siguiente es un extracto significativa desde el código generado por el Azure Blob
de almacenamiento
plantilla, y muestra cómo interactuar con su cuenta de Azure Blob de almacenamiento.
espacio de nombres DataBlobStorage3Sample {
utilizando Microsoft.WindowsAzure;
utilizando Microsoft.WindowsAzure.Storage;
utilizando Microsoft.WindowsAzure.Storage.Blob;
utilizando Sistema;
utilizando System.Collections.Generic;
utilizando System.IO;
utilizando System.Linq;
utilizando System.Threading.Tasks;
/// <Summary>
89
/// Azure Blob de almacenamiento de la muestra - Demostrar cómo utilizar el servicio de almacenamiento Blob.
/// tiendas de almacenamiento de blob de datos no estructurados, tales como texto, datos binarios, documentos o archivos
multimedia.
/// Manchas se puede acceder desde cualquier parte del mundo a través de HTTP o HTTPS.
/// /// Nota: este ejemplo se utiliza el modelo de programación asíncrona .NET 4.5 para demostrar cómo llamar
al servicio de almacenamiento utilizando la
/// bibliotecas de cliente de almacenamiento asincrónica API. Cuando se utiliza en aplicaciones reales,
este enfoque permite mejorar la
/// capacidad de respuesta de la aplicación. Las llamadas al servicio de almacenamiento tienen como prefijo la
palabra clave esperan.
/// /// Referencias Documentación:
/// - ¿Qué es una cuenta de almacenamiento - http://azure.microsoft.com/en-

nosotros / documentación / artículos / almacenamiento whatis cuenta /
/// - Introducción a Blobs - http://azure.microsoft.com/en-
nosotros / documentación / artículos / almacenamiento dotnet-how-to-use-manchas /
/// - Conceptos de Servicio Blob - http://msdn.microsoft.com/en-
es / library / dd179376.aspx
/// - API Blob servicio REST - http://msdn.microsoft.com/en-
es / library / dd135733.aspx
/// - Blob servicio C # API -
http://go.microsoft.com/fwlink/?LinkID=398944
/// - Delegación del acceso con acceso compartido Firmas -
http://azure.microsoft.com/en-us/documentation/articles/storage-dotnetshared-access-signature-part-1/
/// - Emulador de almacenamiento - http://msdn.microsoft.com/en-

es / library / azul / hh403989.aspx
/// - Programación asíncrona con asíncrono y esperar -
http://msdn.microsoft.com/en-us/library/hh191443.aspx
/// </ Summary>
público clase Programa
{
//
***************************************************************************
**********************************************
// Instrucciones: Esta muestra se puede ejecutar utilizando el almacenamiento emulador Azure
que se instala como parte de este SDK - o por
// actualizar el archivo app.config con su Nombre de cuenta y clave. //
// Para ejecutar el ejemplo utilizando el emulador de almacenamiento (opción por defecto) //

1. Iniciar el emulador de almacenamiento Azure (sólo una vez) pulsando
el botón de inicio o la tecla de Windows y la búsqueda de ella
// escribiendo "Azure Storage emulador". Seleccionarlo en la
lista de aplicaciones para iniciarlo.
// 2. Establecer puntos de interrupción y ejecutar el proyecto mediante F10.
//
// Para ejecutar el ejemplo utilizando el servicio de almacenamiento:
90
// 1. Abra el archivo app.config y comentar la conexión
cadena para el emulador (UseDevelopmentStorage = Verdadero) y
// elimine la cadena de conexión para el servicio de almacenamiento
(AccountName = [] ...)
// 2. Crear una cuenta de almacenamiento a través del Portal Azure y
proporcionar a su [Nombre de cuenta] y [AccountKey] en
// el archivo app.config. Ver
http://go.microsoft.com/fwlink/?LinkId=325277 para más información
// 3. Establezca puntos de interrupción y ejecutar el proyecto mediante F10.
// //
***************************************************************************
**********************************************
Consola .Línea de escritura( "Azure Storage Blob Sample \ n" );
// Bloque básico blob.

Consola .Línea de escritura( "Sample Bloquear Blob" );
BasicStorageBlockBlobOperationsAsync () Espera ().;
// avanzadas Page blob.

Consola .Línea de escritura( "Muestra \ nPage Blob" );
BasicStoragePageBlobOperationsAsync () Espera ().;
Consola .Línea de escritura( "Presiona cualquier tecla para salir" );

}
/// <Summary> /// Operaciones básicas para trabajar con gotas de bloque.
/// </ Summary> /// <volverá> Tarea <volverá>
privado asíncrono estática Tarea BasicStorageBlockBlobOperationsAsync () {
const string ImageToUpload = "HelloWorld.png" ;
// Obtiene información de la cuenta de almacenamiento de la cadena de conexión. // Como crear una

cadena de conexión de almacenamiento -
http://msdn.microsoft.com/en-us/library/azure/ee758697.aspx
CloudStorageAccount storageAccount =
CreateStorageAccountFromConnectionString ( CloudConfigurationManager .GetSetti ng ( "StorageConnectionString" ));
// crear un cliente de blob para interactuar con el servicio de blob.

CloudBlobClient blobClient = storageAccount.
CreateCloudBlobClient ();
91
// crear un contenedor para la organización de gotas dentro del almacenamiento
cuenta.
Consola .Línea de escritura( "1. La creación de contenedores" );
CloudBlobContainer contenedor = blobClient. GetContainerReference ( "Democontainerblockblob"
);
tratar
{
esperar container.CreateIfNotExistsAsync (); }
captura ( StorageException ) {
Consola .Línea de escritura( "Si está ejecutando con el valor por defecto
configuración por favor asegúrese de que ha comenzado el emulador de almacenamiento. Pulse la tecla de Windows
Azure y el tipo de almacenamiento para seleccionar y ejecutar desde la lista de aplicaciones - a continuación, reinicie la
muestra ". );
lanzar ; }
// Para ver el código completo de inicio rápido, crear un nuevo Azure Blob de almacenamiento rápida // inicio en Visual
Studio 2015.
Como se puede ver, el código ofrece muestras de las tareas más importantes que usted necesita para llevar a cabo con el escenario
seleccionado. Todo rápida disponible Inicia comportarse de esta manera.
Herramientas del Gestor de Recursos Azure
El SDK de Azure introduce una nueva herramienta llamada Administrador de recursos Azure. Esta nueva herramienta, básicamente, ayuda a
crear tanto un proyecto web y un proyecto de implementación que contiene los artefactos necesarios a los recursos de provisión de Azure, la
creación de un entorno adecuado para la aplicación en su nombre. Se utiliza el Administrador de recursos Azure mediante el aprovechamiento
de una nueva plantilla de proyecto llamado Proyecto de implementación de nube. Esta plantilla de proyecto está disponible en el Nube
nodo de la Nuevo proyecto de diálogo, como se muestra en la Figura 75. Aviso la rica descripción de la plantilla en el lado derecho del cuadro de
diálogo.
92
Figura 75: La plantilla de proyecto de implementación de la nube.
El proyecto de implementación de la nube utiliza plantillas en la Galería de Azure, que permite personalizaciones profundas sino que
también reduce el costo y el esfuerzo cuando se mueve entre los ambientes. Tales plantillas que sea fácil de configurar la
implementación de aplicaciones simplemente especificando alguna información de su suscripción. Para entender cómo funciona esto,
cree un nuevo proyecto usando esta plantilla. Se le pedirá que seleccione una de las plantillas disponibles Azure Gallery, como se
muestra en la Figura 76.
93
Figura 76: Las plantillas Azure Galería.
Nota: En futuras versiones del SDK de Azure, Microsoft también debe añadir plantillas para apuntar servicios como
redes, almacenamiento, y las máquinas virtuales.
Para el ejemplo actual, seleccione la Sitio web + plantilla de SQL ( véase la Figura 76). A continuación, se le pedirá que especifique una
plantilla de proyecto ASP.NET. Basta con seleccionar el Vacío uno, ya que sirve como un ejemplo. A continuación, el proyecto está listo; en
el Explorador de soluciones, verá dos proyectos: el proyecto ASP.NET y un proyecto de despliegue de recursos Azure Gerente, cuyo
nombre termina con
.Despliegue.
Despliegue. Si expande subcarpetas en este proyecto, verá lo siguiente:
• Una referencia al proyecto de ASP.NET, un script de PowerShell que se encarga de la publicación de

recursos a Azure ( Publish-AzureResourceGroup.ps1).
• Una plantilla de implementación ( WebSiteDeploy.json).
• Un archivo de parámetros que contiene valores que utiliza el archivo de configuración ( WebSiteDeploy.param.dev.json).
• Una herramienta de despliegue ( AzCopy.exe).
Suponiendo que tenga su proyecto ASP.NET listo para hacer algunas tareas, ahora se puede preparar para su despliegue en Azure. Al
implementar un proyecto de implementación de la nube, de implementarlo en un grupo de recursos Azure, que es una agrupación lógica de
recursos que incluyen (pero no limitados a) sitios web, bases de datos y almacenes. Haga clic con el. Despliegue nombre del proyecto y
seleccione Desplegar > Nueva implementación. En el El nuevo despliegue de diálogo (ver Figura 77), seleccione el grupo de recursos
opción, que es específica para el escenario actual y haga clic OKAY.
94
Figura 77: El cuadro de diálogo New despliegue.
Ahora verá el Implementar en grupos de recursos de diálogo (ver Figura 78), cuyos campos serán llenados automáticamente por
Visual Studio con valores apropiados, a excepción de la grupo de recursos
caja, lo que requiere la especificación de un grupo de recursos. Este puede ser uno de los grupos creados anteriormente por defecto o.
Figura 78: El Implementar para diálogo grupo de recursos.
Para crear un grupo de recursos, haga clic en el Crear nuevo… opción en el cuadro combinado y en el Crear grupo de recursos de diálogo
especificar un nombre personalizado y la región. Esto debe representar la ubicación más cercana a usted (véase la Figura 79).
95
Figura 79: Creación de un nuevo grupo de recursos.
Antes de implementar la aplicación, se tendrá que modificar los parámetros para el archivo WebSiteDeploy.param.dev.json. Haciendo
click Editar parámetros, usted será capaz de editar los parámetros visuales dentro de la Editar parámetros de diálogo, como se
muestra en la Figura 80.
Figura 80: parámetros de edición para el despliegue.
El número de ajustes varía en función de lo Azure Galería plantilla que seleccione al principio. Verá muchos campos
vacíos y todos ellos son obligatorias; verá un glifo rojo con un signo de exclamación blanco que pone de relieve los
parámetros obligatorios. parámetros obligatorios comunes se resumen en la Tabla 1.
96
Tabla 1: Parámetros obligatorios comunes para la implementación
Parámetro Descripción Valor
Nombre del Sitio Web La primera parte de la URL Por ejemplo, si su sitio se llama
del sitio Web.
vs2015succinctly.azurewe
bsites.net, Aquí se especifica
vs2015succinctly.
webSiteHostingPlanName planes de alojamiento web Un nombre de plan de alojamiento web. Se

representar un conjunto de le recomienda encarecidamente la lectura
características y capacidades que de la
puede compartir a través de sitios la página oficial de Microsoft
web; es compatible con los cuatro sobre la creación de Planes de Alojamiento
niveles de precios de los sitios web Web.
Azure (gratuitos, compartidos,
básicas y estándar).
webSiteLocation La página web de la ubicación Uno de los apoyada Regiones

geográfica. Azure .
se requieren parámetros adicionales cuando se utiliza el El sitio web + SQL plantilla, como en el ejemplo actual.
parámetros relacionados con SQL se resumen en la Tabla 2.
Tabla 2: Parámetros obligatorios SQL
SQLServerName El nombre del servidor de El nombre del servidor es como

base de datos, que puede yourserver.database.wind
ser recuperada en el ows.net, dónde yourserver
representa el nombre de su servidor.
Portal de gestión .
sqlServerLocation El servidor de localización Uno de los apoyada Regiones

geográfica. Esto será Azure .
utilizado si el servidor no
existe todavía.
97
sqlServerAdminLogin Nombre de usuario del Ver Descripción.

administrador de base de datos.
sqlServerAdminPassword La contraseña del Ver Descripción.

administrador.
Cuando esté listo, haga clic Desplegar. Visual Studio 2015 publicará la aplicación a su suscripción Microsoft Azure y crear el
grupo de recursos apropiados, incluyendo la base de datos si no existe. El progreso de la operación se mostrará en la ventana
de salida como de costumbre. A continuación, será capaz de ejecutar y gestionar la aplicación.
Soporte para múltiples cuentas de Microsoft
Como se vio en el Capítulo 1, Visual Studio 2015 introduce soporte para múltiples cuentas de Microsoft. Esto es aún más útil
cuando se habla de Microsoft Azure, porque se puede firmar de forma simultánea en múltiples suscripciones y aprovechar la Explorador
de servidores ventana para administrar sus recursos en la nube. En el Explorador de servidores, haga clic en el Azur nodo y
luego seleccione Administrar y filtrar Suscripciones. Esto abrirá el Manejo de Microsoft Azure Suscripciones de diálogo,
que está representado en la Figura 81.
Figura 81: gestión de las suscripciones Azure.
98
Aquí puede seleccionar o anular la selección de las cuentas que se firmará de forma automática por el Explorador de servidores; en el Suscripciones pestaña
puede seleccionar o anular la selección de las suscripciones de forma que el Explorador de servidores muestra recursos sólo para los seleccionados.
Carpetas de almacenamiento Blob
Visual Studio 2013 y el SDK Azure 2.2 introdujo la posibilidad de interactuar con su cuenta de almacenamiento Azure, que incluye manchas,
tablas y colas, directamente desde dentro del IDE a través de la ventana del Explorador de servidores y su nodo de almacenamiento. Con
respecto al almacenamiento Blob, estas herramientas permiten la creación y gestión de contenedores y carga / descarga de archivos a /
desde los contenedores. Visual Studio 2015 y el SDK Azure 2.5.1 dar un paso más allá al proporcionar soporte para carpetas blob. Estos
permiten gotas a agruparse en unidades lógicas, que es muy útil cuando se está utilizando solamente un contenedor blob. Blob carpetas son
en realidad un prefijo para el nombre de blob; estos prefijos incluyen el / delimitador. Por ejemplo, supongamos que tiene una cuenta de
almacenamiento llamada
vs2015succinctly, con un recipiente llamado documentos y una carpeta llamada burbuja personal, y aquí se tiene un archivo de
Word llamada mydocument.docx. La URL se verá así:
https://vs2015succinctly.blob.core.windows.net/documents/personal/mydocument.docx
Esto es muy intuitivo y recuerda cómo llegar a las carpetas en un sitio web (que es en realidad lo que haces).
Si bien se puede navegar por las carpetas blob existente, no se puede crear carpetas desde el Explorador de servidores; Por lo tanto, se crea
una carpeta de subir nota cuando el primer archivo a la misma. Para una mejor comprensión, siga estos pasos:
1. Haga clic en el blobs nodo en el Explorador de servidores para una de sus cuentas de almacenamiento (estoy
mediante el almacenamiento de desarrollo local para este ejemplo) y seleccione Crear Blob de contenedores.
2. En el Crear Blob de contenedores diálogo, introduzca documentos como el nombre del contenedor (ver
La Figura 82).
3. Haga doble clic en el contenedor recién creado de modo que Visual Studio abre la Envase herramienta
ventana.
4. Haga clic Subir y especificar el nombre del archivo que desea cargar y el nombre de la carpeta,
p.ej personal. La figura 83 muestra un ejemplo.
5. Cuando esté listo, haga clic OKAY. En este punto, Visual Studio muestra el contenido de la personal
carpeta blob y su contenido (véase la figura 84). Aquí puede administrar gotas de la forma habitual.
6. Haga clic Directorio de Padres abierta, que se encuentra cerca del nombre de la carpeta blob. Esto traerá
que el nivel superior y mostrar la lista de carpetas blob en el contenedor actual.
99
Figura 82: Creación de un contenedor de blob.
Figura 83: Carga de un archivo y crear una carpeta blob.
100
Figura 84: Administración de manchas en la carpeta blob.
Es muy importante destacar que la supresión de todas las manchas de una carpeta específica también dará lugar a la eliminación de la carpeta.
La razón es que una carpeta burbuja es sólo una agrupación lógica, no un lugar físico, por lo que cuando se quita todas las manchas de una
carpeta, esto no tiene razón de existir.
La adición de servicios conectados
Visual Studio 2015 y el Azure SDK 2.5.1 hacen que sea más fácil para conectarse a los servicios basados en Azure como Azure
Mobile Services, Azure Storage, Oficina 365, y Salesforce. Para entender las mejoras, suponga que tiene una aplicación Web
ASP.NET. En el Explorador de soluciones, haga clic en el nombre del proyecto y seleccione Añadir > Conectado servicio. los Añadir
relacionada con el servicio diálogo que le ofrece las opciones que se pueden ver en la Figura 85.
101
Figura 85: Adición de un servicio Conectado.
Digamos que quiere conectarse a Azure de almacenamiento; seleccionar Azure Storage y haga clic Configurar. En este punto se le pedirá
que seleccione una de sus cuentas de almacenamiento en el diálogo de Azure Storage (ver Figura 86), donde también tendrá la opción de
cambiar las cuentas de Microsoft fácilmente.
Figura 86: Selección de una cuenta de almacenamiento.
102
Al hacer clic Añadir, Visual Studio iniciará el explorador Web predeterminado que apunta a una página web “inicio” donde se
obtiene una guía sobre el código que necesita para interactuar con en el servicio conectado a tu elección. La figura 87
muestra un ejemplo basado en la selección actual.
Figura 87: Obtención de guía sobre el código que necesita en el escenario actual.
Lo más importante, Visual Studio 2015 agrega automáticamente las referencias a las bibliotecas necesarias invocando NuGet y la cadena
de conexión en el archivo Web.config. Esto sucede con cualquier servicio conectado a elegir en el Añadir relacionada con el servicio diálogo.
Al describir cómo funciona cada servicio es imposible en este libro, por lo que este se deja a sus estudios posteriores. Lo que es importante
subrayar aquí es cómo la nueva forma de hacer referencia a los servicios hace las cosas más rápido y más fácil.
Análisis de código de Azure
El compilador plataforma .NET, anteriormente conocido como Project Roslyn, proporciona compiladores con el análisis de código en tiempo
real y detección cuestión a medida que escribe. Estas capacidades se ilustran con ejemplos en el capítulo 3, con respecto a las bombillas y
acciones rápidas. Microsoft también ha creado un conjunto de reglas adicionales específicamente para Azure, que analiza los problemas en el
código y sugiere posibles soluciones. El análisis de código para Azure está disponible como un paquete NuGet. Dicho esto, suponiendo que
tiene un proyecto de Azure como un rol web o un rol de trabajo, busque el paquete de análisis de código Azure como se muestra en la Figura
88.
103
Figura 88: Adición de análisis de código Azure para sus proyectos.
Cuando se instala el paquete, los compiladores son capaces de comprobar el cumplimiento del código de las reglas Azure y las mejores
prácticas en tiempo real. Por ejemplo, la Figura 89 muestra un problema con el correr
método en un rol de trabajo, que se ha marcado como asíncrono pero no es compatible con las reglas Azure; La Figura 89 también
muestra la bombilla de luz en acción.
104
Figura 89: Adición de análisis de código Azure para sus proyectos.
El análisis de código Azure es particularmente útil cuando se crean aplicaciones con un objetivo highscalability,
porque sugiere las mejores prácticas y ayuda a escribir código mejor y más eficiente.
Soporte HDInsight
El SDK 2.5.1 Azure y Visual Studio 2015 tienen soporte para HDInsight servicios para grandes volúmenes de datos y para Colmena para consultar
bases de datos. Soporte es de plantillas de proyecto (véase la Figura 90) que incluyen una muestra de la colmena, que viene con un código de
demostración, y una interacción con los objetos Explorador de servidores HDInsight, exactamente como lo haría con cualquier otro servicio de
suscripción.
105
Figura 90: Creación de proyectos con el apoyo de la colmena HDInsight.
La plantilla de la muestra de la colmena (ver Figura 90) le da una idea de cómo funciona HDInsight. Si hace doble clic en una
plantilla para crear un proyecto de ejemplo, verá cómo Visual Studio genera dos
. archivos HQL, cada uno conteniendo consultas SQL específicos contra los sitios web Azure (WebLogAnalysis.hql) y los sensores de los
dispositivos de los (SensorDataAnalysis.hql), respectivamente. La lista siguiente reproduce el código de ejemplo para WebLogAnalysis.hql.
Tenga en cuenta que los comentarios explican cómo cada fragmento de código funciona y cómo el código está hecho de nodos sintaxis familiar
basados en SQL.
- - Parte 1: Introducción
-- En este ejemplo se utilizará una consulta HDInsight que analiza los archivos de registro del sitio web
-- para obtener una idea de cómo los clientes utilizan el sitio web. Con este análisis, se puede ver
-- la frecuencia de las visitas al sitio en un día de sitios web externos, y una
-- resumen de los errores de sitios web que experimentan los usuarios.
-- En este tutorial, aprenderá cómo utilizar HDInsight a:
-- * Conectarse a una página web que contiene los archivos de registro de almacenamiento Azure Blob.
-- * Crear tablas de la colmena la consulta de dichos registros.
-- * Colmena crear consultas para analizar los datos.
- - Parte 2: Requisitos
-- La secuencia de comandos aquí es sólo para su referencia. Es necesario iniciar sesión en
-- https://yourclusteraddress.azurehdinsight.net/ el fin de desencadenar la HDInsight
-- servicio para cargar los datos de la muestra.
-- Para los clústeres provisionados antes de 15/10/2014, vaya a
-- http://azure.microsoft.com/en-us/documentation/services/hdinsight/ para más detalles
-- ya que esos grupos no tienen instalados los datos de la muestra.
106
- - Parte 3: Sitio Web de registro de datos cargado en almacenamiento de Windows Azure Blob
-- Los datos almacenados en el almacenamiento de Windows Azure Blob se puede acceder mediante la ampliación de una
-- HDInsight clúster y haga doble clic en el contenedor predeterminado de su almacenamiento por defecto
-- cuenta. Los datos para esta muestra se pueden encontrar bajo la
-- / HdiSamples / WebsiteLogSampleData / SampleLog camino en su contenedor predeterminado.
- - Parte 4: Creación de la tabla de la colmena a Query sitio web de registro de datos

-- La siguiente declaración de la colmena crea una tabla externa que permite la colmena para consultar
-- datos almacenados en Azure Blob Storage. Las tablas externas conservan los datos en el original
-- Formato de archivo, al tiempo que permite la colmena de realizar consultas a los datos dentro del archivo.
-- La declaración de la colmena a continuación crea una nueva tabla, los weblogs con nombre, con la descripción de la
-- campos dentro de los archivos, el delimitador entre los campos, y la ubicación del archivo
-- en Azure Blob de almacenamiento. En la creación de consultas colmena para Analizar la sección de datos de este
-- tutorial, realizar consultas sobre los datos almacenados en esta tabla.
-- También podría crear una tabla haciendo clic derecho en una base de datos y seleccionar
-- "Crear mesa". Nosotros le proporcionaremos con una interfaz de usuario para ayudar a crear esta tabla.
SOLTAR TABLA SI EXISTE weblogs;

-- Crear weblogs de mesa en los datos de registro web delimitados por espacios.
-- En esta muestra se utilizará el contenedor predeterminado. También es posible usar
-- 'Wasb: // [recipiente] @ [cuenta de almacenamiento] .blob.core.windows.net / ruta / a / Datos /' para acceder
-- los datos en otros recipientes.
CREAR TABLA EXTERNO SI NO EXISTE weblogs (s_date fecha ,
s_time cuerda , s_sitename cuerda , cs_method cuerda , cs_uristem cuerda , cs_uriquery cuerda , s_port En t ,
cs_username cuerda , c_ip cuerda , cs_useragent cuerda , cs_cookie cuerda , cs_referer cuerda , cs_host cuerda ,
sc_status En t , sc_substatus En t , sc_win32status En t , sc_bytes En t , cs_bytes En t , s_timetaken En t )
FILA FORMATO campos delimitados SUSPENDIDO POR ''

almacenan como ARCHIVO DE TEXTO UBICACIÓN '/ HdiSamples / WebsiteLogSampleData / SampleLog /'
TBLPROPERTIES ( 'Skip.header.line.count' = '2' );
-- Las siguientes consultas HIVE crean dos nuevas tablas basadas en las consultas se ejecutan en el
-- mesa de weblogs. Las nuevas tablas se llaman clienterrors y refersperday.
-- La consulta de clienterrors extrae datos de la tabla weblogs de estado HTTP
-- códigos entre 400 y 500, y los agrupa por parte de los usuarios frente a los errores y la
-- tipo de códigos de error. La gama de código de estado entre 400 y 500, representado por
-- sc_status columna en la tabla de los weblogs, corresponde a los errores, mientras que los clientes obtengan
-- acceso al sitio Web. Los datos extraídos se ordena en el número de
-- ocurrencias de cada código de error y por escrito a la mesa clienterrors.
-- La consulta de refersperday extrae datos de la tabla para todos los weblogs externa
-- sitios web de referencia a este sitio web. La información se extrae sitio web externo
-- de la columna de la tabla cs_referer de weblogs. Para asegurarse de que los enlaces referentes hicieron
-- no se produzca un error, la tabla sólo se muestran los datos de las páginas que devuelven un HTTP
-- código de estado entre 200 y 300. Los datos extraídos a continuación, se escribe en el
-- refersperday mesa.
SOLTAR TABLA SI EXISTE ClientErrors;

-- Crear ClientErrors tabla para almacenar los errores de los usuarios experimentados y sus frecuencias.
CREAR TABLA EXTERNO ClientErrors (sc_status En t , cs_referer cuerda , cs_page cuerda , cnt En t )
107
FILA FORMATO campos delimitados SUSPENDIDO POR '' ;
-- Poblar ClientErrors tabla con datos de weblogs de mesa.

INSERTAR TABLA SOBRESCRIBIR ClientErrors
SELECCIONAR sc_status, cs_referer,
concat (cs_uristem, '?' , REGEXP_REPLACE (cs_uriquery, 'X-ARR-LOG-ID = [0-9a-
f] {8} - [0-9a-f] {4} - [0-9a-f] {4} - [0-9a-f] {4} - [0-9a-f] {12}' , '' )) Cs_page,
contar ( distinto c_ip) como cnt
DESDE weblogs
DÓNDE sc_status> = 400 y sc_status <500
AGRUPAR POR sc_status, cs_referer, concat (cs_uristem, '?' , REGEXP_REPLACE (cs_uriquery, 'XARR-log-ID = [0-9a-f] {8} - [0-9a-f] {4} -
[0-9a-f] {4} - [0-9a-f] {4} - [0-9a-f] {12}' , '' ))
ORDER BY cnt;
SOLTAR TABLA SI EXISTE RefersPerDay;

-- Crear RefersPerDay tabla para almacenar referencias de sitios web externos.
CREAR TABLA EXTERNO SI NO EXISTE RefersPerDay (años En t , mes En t , día En t , cs_referer cuerda , cnt En t )
FILA FORMATO campos delimitados SUSPENDIDO POR '' ;
-- Poblar RefersPerDay tabla con datos de la tabla weblogs.

INSERTAR TABLA SOBRESCRIBIR RefersPerDay
SELECCIONAR año (s_date), el mes (s_date), día (s_date), cs_referer, contar ( distinto c_ip) como
cnt
DESDE weblogs
DÓNDE sc_status> = 200 y sc_status <300
AGRUPAR POR s_date, cs_referer
ORDER BY cnt desc ;
- - Parte 6: Ejecutar consultas y visualización de los resultados

-- Seleccione Enviar / Enviar (Avanzado) en la barra de herramientas HDInsight a ejecutar las consultas. usted
-- También se puede usar Alt + Shift + S para una presentación rápida. Después de enviar el trabajo, puede
-- ver detalles haciendo clic derecho en el clúster y seleccionando "Ver Colmena Empleo".
-- También puede ampliar las bases de datos de la colmena y haga clic derecho en las tablas que acaba de crear, seleccione
"View Principales 100 Filas" y muestra la tabla que acaba de crear.
Por supuesto, tendrá que sustituir los nombres de sitios Web de ejemplo con los suyos, y para ajustar el código en función de sus
necesidades y servicios, pero es un buen ejemplo para entender el propósito de HDInsight.
La introducción de WebJobs
Azure WebJobs proporciona la capacidad de ejecutar programas, como .exe y .cmd archivos, en los sitios web de Azure. Usted puede tener
muchas razones para ejecutar un programa, como ejecutar tareas en segundo plano, el trabajo intensivo de la CPU, procesamiento de
imágenes al cargar gotas, agregación de RSS, y otros. Para hacer más fácil la programación WebJobs, Microsoft también lanzó una WebJobs
SDK , Que proporciona un marco simplificado que reduce al mínimo el esfuerzo y reduce la cantidad de código que necesita para escribir. El
SDK 2.5.1 Azure para Visual Studio 2015 proporciona soporte para el IDE de varias maneras. En primer lugar, usted tiene plantillas de
proyecto. los Nube nodo de la Nuevo proyecto diálogo contiene una plantilla de proyecto llamado Azure WebJob, como se muestra en la
Figura 91.
108
Figura 91: plantilla de proyecto WebJob Azure.
Sin embargo, esta es la plantilla más básica del proyecto y proporciona ningún código. En su lugar, puede utilizar Inicia el Azure rápida para
empezar con los ejemplos del SDK; La Figura 92 muestra los WebJobs de inicio rápido.
109
Figura 92: Azure WebJobs rápida se inicia desde el SDK.
Por ejemplo, la plantilla Azure Blob WebJobs SDK muestra cómo utilizar el almacenamiento Azure Blob con WebJobs. Más
específicamente, este ejemplo muestra cómo leer / escribir objetos en una cola y la forma de escribir la información en un archivo de
texto. Como se puede ver en la Figura 92, ejemplos similares están disponibles para otros servicios Azure. Para publicar WebJobs a un
sitio web de Azure, se haga clic en el nombre del proyecto en el Explorador de soluciones y seleccionar Publicar como Azure WebJob. En
este punto el Añadir Azure WebJob diálogo aparece (ver Figura 93) y permite que la información que especifica como el nombre, modo
de ejecución ( Funcionar continuamente, se ejecutarán a intervalos, correr bajo demanda), además de comienzo y fin en caso de
que su WebJob representa una operación recurrente.
110
Figura 93: Azure WebJobs rápida se inicia desde el SDK.
Cuando el WebJob se publica en Azure, el Explorador de servidores permitirá lo siguiente:
• Mostrar un nodo WebJobs bajo el nombre del sitio web relacionado.

• Conectar el depurador para la depuración remota a la WebJob especificado.
• Iniciar y detener WebJobs.
Todas estas interacciones han sido posibles debido a la WebJobs SDK, que no sólo simplifica la cantidad de código que escribe, sino
que también hace que sea más fácil trabajar con WebJobs a través de herramientas visuales.
En este capítulo se explica algunas de las características clave en Visual Studio 2015 para el desarrollo web y la nube. En la primera parte, que ha
aprendido sobre los nuevos plantillas de proyectos que permiten a los desarrolladores acceder a la ejecución Core ASP.NET 5.0. A continuación,
aprendió las plantillas están organizadas en un nuevo sistema de proyectos, con nuevos archivos de proyecto, los nuevos archivos JSON para la
configuración, y una gestión de paquetes más fácil que permite este tipo de aplicaciones que se ejecutan multiplataforma y utilizando sólo los
paquetes necesarios a través de NuGet. En la segunda parte del capítulo, que se convirtió en familiarizarse con nuevas herramientas para Microsoft
Azure, tales como arranques rápidos plantillas y soporte para múltiples cuentas de Microsoft Project para conectarse fácilmente a la nube de
recursos de Explorador de servidores. Ha aprendido Visual Studio 2015 permite carpetas Blob gestión y cómo se simplifica la forma de agregar
servicios relacionados con sus proyectos. Usted aprendió sobre el análisis de código para el paquete de Azure, que proporciona en tiempo real de
análisis de código y sugerencias apropiadas a posibles problemas de código. Por último, ha aprendido cómo interactuar con los servicios HDInsight
para grandes volúmenes de datos y cómo ejecutar los programas de fondo en sus sitios web a través de WebJobs.
111
Capítulo 9 Visual Studio 2015 para móviles
Desarrollo
Las últimas versiones de Visual Studio proporciona un soporte óptimo para la creación de aplicaciones móviles en la parte superior de los sistemas
operativos de Microsoft y plataformas, como Windows 7.x de teléfono, teléfono de Windows
8.x, y 8.x de Windows Sin embargo, estos entornos de desarrollo sólo son compatibles con el desarrollo de aplicaciones para dispositivos con
sistemas operativos de Microsoft. No es ningún secreto que un papel muy importante en el mercado de dispositivos móviles, como tabletas y teléfonos
inteligentes, es interpretado por los sistemas operativos Android y iOS. Microsoft es consciente de esto y con Visual Studio 2015 que se abren a
nuevos escenarios, proporcionando herramientas para la creación de aplicaciones móviles multiplataforma. En este capítulo se proporciona con un
fondo sobre las posibilidades que tiene en Visual Studio 2015 y explica las nuevas oportunidades para diferentes plataformas.
El fondo
Uno de los mayores objetivos para los desarrolladores que trabajan en aplicaciones móviles es la capacidad de escribir una aplicación una vez y ver que
funcione en múltiples dispositivos y sistemas operativos. Esto es en realidad el significado de desarrollo móvil de plataforma cruzada. Sin lugar a dudas,
Microsoft Visual Studio ha sido el mejor entorno de desarrollo durante muchos años. El IDE es compatible con muchos idiomas (incluyendo HTML 5 y
JavaScript, el lenguaje más popular para la creación de aplicaciones multiplataforma), ofrece a los diseñadores ricos para cada plataforma de desarrollo
apoyado, editores de código interactivos, integración depurador, análisis de código, y características de productividad. También simplifica cómo los
desarrolladores gestionar el ciclo de vida de desarrollo de aplicaciones con potentes herramientas y servicios visuales. Antes de Visual Studio 2015, sólo los
desarrolladores que crean aplicaciones para Windows Phone y Windows 8. X podría aprovecharse de un entorno de desarrollo tan rico. La única excepción es
Visual Studio 2013, lo que permite el desarrollo multiplataforma con un producto de terceros por Xamarin. Visual Studio 2015 y el nuevo ecosistema .NET
marcan una época revolucionaria por Microsoft: la empresa está abierta-abastecimiento de muchos bloques de construcción del tiempo de ejecución de .NET.
Del mismo modo, Visual Studio 2015 ahora permite la creación de aplicaciones móviles multiplataforma utilizando plataformas non-.NET y bibliotecas para
apuntar a los sistemas operativos Android y iOS. Esto significa que Microsoft está tratando de atraer a los desarrolladores que han estado utilizando entornos
menos evolucionadas como Eclipse y Cacao / Objective C; los desarrolladores pueden finalmente utilizar Visual Studio para aprovechar todas sus herramientas
eléctricas y productividad. lo que permite el desarrollo multiplataforma con un producto de terceros por Xamarin. Visual Studio 2015 y el nuevo ecosistema .NET
marcan una época revolucionaria por Microsoft: la empresa está abierta-abastecimiento de muchos bloques de construcción del tiempo de ejecución de .NET.
Del mismo modo, Visual Studio 2015 ahora permite la creación de aplicaciones móviles multiplataforma utilizando plataformas non-.NET y bibliotecas para
apuntar a los sistemas operativos Android y iOS. Esto significa que Microsoft está tratando de atraer a los desarrolladores que han estado utilizando entornos
menos evolucionadas como Eclipse y Cacao / Objective C; los desarrolladores pueden finalmente utilizar Visual Studio para aprovechar todas sus herramientas eléctricas y productividad
¿Qué aplicaciones móviles puedo construir con VS 2015?
Visual Studio 2015 es el entorno de desarrollo más completo para la creación de aplicaciones móviles. Con este lanzamiento, se
puede construir:
• Aplicaciones para Windows 10. En el momento de la publicación, Windows 10 está disponible como una Technical Preview y usted puede
construir aplicaciones para la versión preliminar mediante la instalación del herramientas de desarrollo para Visual Studio 2015 .
• Aplicaciones para Windows 8 y Windows 8.1 utilizando XAML y C # / VB.
112
• Aplicaciones para Windows Phone 8 y Windows Phone 8.1 utilizando XAML y C # / VB.
• Universal de aplicaciones de Windows usando XAML y C #. Visual Basic también es apoyado pero requiere algunos
pasos adicionales, manuales.
• Aplicaciones para Windows 8 y Windows 8.1 utilizando bibliotecas WinJS (HTML5 / JavaScript).
• Aplicaciones para Windows Phone 8 y Windows Phone 8.1 que utilizan las bibliotecas WinJS (HTML5 /
JavaScript).
• Universal de aplicaciones de Windows usando bibliotecas WinJS (HTML5 / JavaScript).
• aplicaciones de plataforma cruzada para Windows, Windows Phone, Android y iOS con C # / F # y XAML la instalación de
extensiones y herramientas de Xamarin .
• aplicaciones de plataforma cruzada para Windows, Windows Phone, Android 2.3.3 y posteriores, y el IOS (6,
7, y 8) usando Apache Cordova y Visual Studio Tools integradas para Apache Cordova.
Nota: el desarrollo de 10 aplicación de Windows no se trata en este libro porque el modelo de aplicación universal plataforma
Windows es un entorno muy complejo; también hay varias maneras de desarrollar aplicaciones universales, incluyendo
portar iOS existentes y el código de Android, que cubrirían un libro entero.
Microsoft y Xamarin se unieron en una asociación para hacer una mejor integración de herramientas en Visual Studio 2015. Sin embargo,
la suite Xamarin no se distribuye con Visual Studio y es un producto que se debe adquirir por separado. Para la creación de aplicaciones
para Windows y 8.x 8.x Windows Phone, ya sea con XAML / .NET o HTML5 / JavaScript, la biblioteca de MSDN ofrece muy buena
documentación. Dicho esto, en este capítulo nos centramos en nuevas herramientas para la creación de aplicaciones que utilizan las API
de JavaScript de Apache Cordova con Visual Studio 2015, incluyendo un nuevo emulador de Android incorporado por Microsoft.
Nota: A partir de ahora, me referiré a Apache Cordova, ya sea con su nombre completo o, simplemente, con Córdoba.
Requisitos previos
Para desarrollar aplicaciones móviles multiplataforma con Visual Studio 2015 y Apache Cordova, es necesario instalar algunos
requisitos previos. Estos se resumen en la Tabla 3.
Tabla 3: Apache Cordova Requisitos previos
Requisito previo Descripción
Apache Ripple Emulador para Android y el IOS.
Google Chrome navegador web y componentes necesarios para ejecutar el

emulador Ripple.
113
Requisito previo Descripción
1.8.0 Apache Ant Se requiere para el proceso de generación de Android.
SDK de Android Se requiere para el proceso de generación de Android y para el

emulador Ripple.
SDK Java de Oracle 7 Se requiere para el proceso de generación de Android.
Node.js Se integra Visual Studio con el Apache Cordova

Command Line Interface (CLI) y el emulador Ripple.
apple iTunes Necesarios para implementar de forma remota una aplicación para un
dispositivo iOS.
El Visual Studio 2015 instalador instalará todos los requisitos previos para que, sólo asegúrese de seleccionar todos los componentes
necesarios en la ventana de bienvenida del instalador.
Nota: Hyper-V es otro requisito previo, ya que se requiere para ejecutar el emulador de Visual Studio para Android y
emuladores para Windows Phone 8.1.
La creación de aplicaciones para iOS
aplicaciones de iOS no pueden construirse en Windows. Esto no es una limitación de Windows; es en cambio la licencia de Apple
requiere que los desarrolladores crear aplicaciones en un Mac. Por esta razón, con el fin de utilizar Visual Studio 2015 y Apache
Cordova para construir aplicaciones para iOS, se necesita un ordenador Mac y una configuración adicional para la depuración remota.
La documentación de MSDN tiene una documento específico sobre la configuración de un entorno con iOS. En este libro, no cubrimos el
desarrollo de iOS porque no podemos asumir los lectores tienen un Mac y porque nos centramos en las herramientas que se pueden
utilizar en Windows y Visual Studio. En este capítulo, se habla de desarrollo de Android con Visual Studio 2015.
114
La creación de aplicaciones con Apache Cordova
Apache Cordova es un proyecto de código abierto que proporciona un rico conjunto de APIs que permiten a los desarrolladores acceder a las funciones nativas
de los dispositivos de código JavaScript. Por ejemplo, con estas API se puede acceder fácilmente a la cámara del dispositivo o de otros sensores. Cuando se
utiliza Apache Cordova, que básicamente utiliza JavaScript y no escribir una sola línea de lenguas nativas como Java, Objective-C (IOS), o C #. JavaScript API
de Cordova sólo permiten el acceso a las capacidades del dispositivo, por lo que necesita una combinación con un marco de interfaz de usuario, tales como
jQuery Mobile o Dojo Mobile. La combinación de Córdoba y un marco de interfaz de usuario permite escribir aplicaciones para dispositivos móviles con HTML,
CSS y JavaScript. Tanto las API de JavaScript de Cordova y marcos de interfaz de usuario son consistentes a través de múltiples plataformas de dispositivos,
por lo que una aplicación que se construye con Córdoba puede ejecutarse en múltiples sistemas operativos y dispositivos. Aquí es donde Microsoft Visual Studio
2015 entra en acción. El IDE integra el entorno habitual, de gran alcance visual con todas sus herramientas con Apache Cordova para proporcionar la mejor
experiencia de desarrollo de aplicaciones móviles multiplataforma, y hace que sea fácil de integrar proyectos Cordova con IU marcos. Después de todo, Visual
Studio ha tenido un mejor soporte para JavaScript durante muchos años, con mejoras continuas realizados en el editor de código. Por supuesto, se supone que
usted sabe cómo código en JavaScript para tomar ventaja de las características descritas en este capítulo. Visual Studio ha tenido un mejor soporte para
JavaScript durante muchos años, con mejoras continuas realizados en el editor de código. Por supuesto, se supone que usted sabe cómo código en JavaScript
para tomar ventaja de las características descritas en este capítulo. Visual Studio ha tenido un mejor soporte para JavaScript durante muchos años, con mejoras
continuas realizados en el editor de código. Por supuesto, se supone que usted sabe cómo código en JavaScript para tomar ventaja de las características
descritas en este capítulo.
Visual Studio Tools para Apache Cordova
Detrás de las escenas, Visual Studio 2015 es capaz de apoyar el desarrollo con Córdoba a través de Visual Studio Tools para Apache
Cordova, una extensión que forma parte de la IDE. Entre otras, estas herramientas ofrecen una plantilla de proyecto llamado App
Blank (Apache Cordova), que se encuentra en el
Apache Cordova Aplicaciones nodo bajo el JavaScript carpeta, en el Nuevo proyecto de diálogo (ver Figura 94).
115
Figura 94: La plantilla de proyecto Apache Cordova.
Cuando se crea un proyecto de Córdoba, Visual Studio muestra una página de “Introducción” con muchos enlaces útiles; verá muchos
elementos comunes en el Explorador de soluciones (véase la Figura 95) como:
• Un index.html archivo, que es la pantalla principal de la aplicación.

• UNA config.xml archivo, que contiene información de configuración y que puede ser editado con un editor visual basta con hacer
doble clic en él.
• carpetas específicas de la plataforma que contienen iconos optimizados, recursos y guiones para Android, iOS y Windows /
Windows Phone.
• UNA res carpeta, que contiene código JavaScript específico de la plataforma. Se organiza en subcarpetas, cada uno
para una plataforma específica.
• UNA guión carpeta, la ubicación predeterminada de los archivos JavaScript o mecanografiado.
116
Figura 95: La estructura del proyecto Apache Cordova.
Configurar el proyecto haciendo doble clic en el config.xml expediente. Al hacer esto, Visual Studio 2015 muestra un diseñador
especial, que se muestra en la Figura 96.
117
Figura 96: Configuración de las propiedades de aplicaciones comunes.
El diseñador de configuración está hecha de seis pestañas. La ficha Común es acerca de las propiedades comunes, que son todos fáciles
de entender. La pestaña plataforma le permite especificar la versión para el Córdoba CLI (interfaz de línea de comandos), la infraestructura
necesaria para crear y probar aplicaciones Cordova. La pestaña Plug-ins (ver Figura 97) es muy importante, ya que le permite añadir
plugins; cada plugin proporciona una API para acceder a las características específicas del dispositivo.
118
Figura 97: Adición de funcionalidades de acceso al dispositivo con plugins.
Vale la pena mencionar que, para cada plugin, Visual Studio 2015 muestra las plataformas compatibles. Cuando se agrega un plugin, Visual Studio
agrega al proyecto una serie de archivos JavaScript y archivos específicos de la plataforma que se puede descubrir fácilmente en el Explorador de
soluciones. Las otras pestañas permiten configurar opciones específicas de la plataforma, en especial la información de las tiendas de aplicaciones.
Explorar esas pestañas se os deja como ejercicio. Para entender cómo las pruebas de aplicaciones de obras, una buena idea es utilizar uno de los
ejemplos existentes de Apache Cordova.
Nota: El uso de un ejemplo existente es también una buena idea porque este libro no explica plugins o detalle todas las
API Cordova.
La documentación de MSDN ofrece una aplicación de ejemplo denominado Lista de quehaceres . Este ejemplo está disponible en tres sabores
diferentes, cada uno con un marco de interfaz de usuario diferente. Para el ejemplo actual, la descarga versión AngularJS y extraer el archivo
descargado .zip en una carpeta local en su disco duro. La aplicación ToDoList es muy agradable, ya que es también un ejemplo de cómo utilizar
los mapas de Bing y servicios conectados. Suponiendo que haya abierto la solución de muestra en Visual Studio 2015, en este punto desea
probar la aplicación de ejemplo. Seleccione el sistema operativo de destino, que se puede hacer a través del cuadro combinado apropiado en la
barra de herramientas estándar, como se muestra en la Figura 98.
119
Figura 98: Especificación del sistema operativo de destino.
A continuación, usted tiene que seleccionar la que desea ejecutar la aplicación, que puede ser un dispositivo físico o un emulador, como se muestra en
la Figura 99.
Figura 99: Selección de un dispositivo físico o un emulador.
Tiene varias opciones diferentes, especialmente para Android. Usted tiene el emulador de Android, que se incluye en el SDK de
Android, así como el emulador Ripple, que se incluye con Córdoba; Por último, usted tiene el nuevo emulador de Visual Studio
para Android. Para el ejemplo actual, seleccione la
VS emulador de Android teléfono y pulse F5.
El emulador de Visual Studio para Android
Además de los emuladores de Android existentes, Microsoft ha desarrollado un nuevo emulador de Visual Studio para Android. La figura
100 muestra la aplicación de ejemplo se ejecuta dentro de este nuevo emulador.
120
Figura 100: El emulador de Visual Studio para Android.
Si usted ha construido aplicaciones para Windows Phone, el emulador de Android le resultará familiar, ya que tienen diseños y herramientas similares;
ambos incluyen la capacidad de simular los sensores como el acelerómetro y la ubicación, o para tomar capturas de pantalla. Este emulador también
ofrece una característica importante para las pruebas, que está ajustando el nivel de batería. El emulador también tiene soporte para la cámara, que
simula una tarjeta SD, reproducción de audio y entrada de teclado. En el Estudio Visual Blog se puede encontrar una detallada entrada en el blog
características sobre disponibles en el emulador de Android. Detrás de las escenas, Visual Studio crea una máquina virtual alojada en
Hyper-V. tutoriales adicionales y ejemplos de código se pueden encontrar en la
documentación de MSDN .
Embalaje e implementación de Apache Cordova Aplicaciones
Como regla general, las aplicaciones móviles deben ser empaquetados en un archivo binario adecuado y se despliegan a las tiendas de las
plataformas. Android, iOS y Windows aplicaciones tienen diferentes características y diferentes tiendas. Afortunadamente, Visual Studio 2015
hace que sea fácil crear paquetes para todas las plataformas soportadas mediante la edición del archivo config.xml a través de un diseñador
conveniente. Cuando se genera la solución, Visual Studio crea una subcarpeta llamada bin donde se pueden encontrar paquetes para cada
plataforma. Una vez que usted ha construido su proyecto, tendrá que implementar el paquete de aplicación a la tienda adecuada, como lo haría
normalmente. Información adicional sobre la construcción de paquetes se puede encontrar en el MSDN específica página .
121
desarrollo de aplicaciones móviles multiplataforma es un tema clave cuando se habla de Visual Studio 2015. En este capítulo se le dio una visión
general de las posibilidades que tiene actualmente para construir aplicaciones móviles con Visual Studio. A continuación, aprendió acerca de
nuevas características para la creación de aplicaciones móviles para Android y iOS, así como para Windows y 8.x 8.x Windows Phone, con el
Visual Studio Tools para Apache Cordova. Tiene plantillas del proyecto, el estudio completo de herramientas Visual, y ahora un nuevo Visual
Studio emulador para Android, lo que simplifica el proceso de probar sus aplicaciones mediante la simulación de las capacidades del dispositivo.
122

Visual Studio 2015 PDF - En.es

Cargado por

Copyright:

Formatos disponibles

Visual Studio 2015 PDF - En.es

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Visual Studio 2015 PDF - En.es

Cargado por

Copyright:

Formatos disponibles

1

Visual Studio 2015

Prólogo de Daniel Jebaraj

2501 Centro aérea Parkway

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.

Crítico técnica: Matt Duffield

Coordinador de adquisiciones: Hillary Bolos, coordinador de marketing, Syncfusion, Inc.

Corrector de pruebas: Morgan Cartier Weston, productor de contenidos, Syncfusion, Inc.

La historia detrás de la Sucintamente Serie de Libros ............................................... .................................... 7

Sobre el Autor ............................................... .................................................. ........................................ 9

Introducción ................................................. .................................................. ............................................ 10

Capítulo 1 Cuenta de Gestión de la Experiencia ............................................. ........................................... 11

Administración de cuentas ................................................ .................................................. .......................... 11

Automático de sesión de Servicios de Microsoft ............................................ .................................................. . 14

Resumen del capítulo ................................................ .................................................. ................................ dieciséis

Capítulo 2 proyectos compartidos .............................................. .................................................. ...................... 17

La comprensión de los proyectos compartidos ............................................... .................................................. ............ 17

La creación y consumo de proyectos compartidos ............................................. ............................................... 17

Resumen del capítulo ................................................ .................................................. ................................ 30

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

Gestos táctiles ................................................ .................................................. ................................... 31

La información sobre herramientas coloreadas ................................................ .................................................. ................................ 31

Bombillas y Acciones rápidas ............................................. .................................................. ................ 32

Encontrar y corregir código redundante ............................................. .................................................. .... 33

La fijación de errores ................................................ .................................................. ....................................... 34

La aplicación de Refactorizaciones ................................................ .................................................. ........................ 38

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

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

Definición vistazo en el Editor de código XAML ........................................... .................................................. . 48

Consideraciones adicionales para Peek Definición En XAML ........................................... ............................ 51

Resumen del capítulo ................................................ .................................................. ................................ 52

Ventana Diseño personalizado ............................................... .................................................. ........................ 53

El ahorro de ventana Presentaciones ............................................... .................................................. ..................... 53

La aplicación de la ventana Presentaciones ............................................... .................................................. ................... 55

La gestión de ventanas diseños personalizados .............................................. .................................................. .... 56

Restaurando el diseño predeterminado .............................................. .................................................. .............. 57

Resumen del capítulo ................................................ .................................................. ................................ 57

Capítulo 6 Error Lista Revisited y depuración Mejoras .......................................... .................. 58

La lista de errores Revisited .............................................. .................................................. ......................... 58

Las mejoras de depuración ................................................ .................................................. .................... 61

Soporte para Expresiones Lambda Depuración ............................................. ........................................ 61

La visualización de información sobre herramientas de rendimiento: PerfTips ............................................. ............................................ 63

Herramientas diagnosticas ................................................ .................................................. ................................ 71

Resumen del capítulo ................................................ .................................................. ................................ 75

Capítulo 7 Gestión de paquetes NuGet ............................................. .................................................. .... 76

Una nueva NuGet ............................................... .................................................. ........................................ 76

Configuración de las preferencias NuGet ............................................... .................................................. ................. 78

Resumen del capítulo ................................................ .................................................. ................................ 79

Capítulo 8 Visual Studio 2015 para ASP.NET y Azure ....................................... .................................. 80

Requisitos previos Capítulo ................................................ .................................................. .......................... 80

Visual Studio 2015 para ASP.NET 5 .......................................... .................................................. ............ 81

Plantillas de proyecto Core 5 ASP.NET ........................................... .................................................. ....... 81

Un sistema nuevo proyecto .............................................. .................................................. ......................... 83