PROGRAMA
MÓDULO 1. INTRODUCCIÓN A .NET
DE
ENSEÑANZA
CORE
ABIERTA .NET Y VISUAL STUDIO
2018-2019
|Equipo Docente de .NET y VISUAL STUDIO
PROGRAMA DE FORMACIÓN PROFESIONAL Y PERSONAL
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA
Introducción al Visual Studio
INDICE DE CONTENIDOS
1. INTRODUCCIÓN ......................................................................................................................................... 4
2. USO DE .NET CORE ................................................................................................................................... 6
2.1. INSTALACIÓN DE .NET CORE ................................................................................................................ 6
3. .NET CORE CON VISUAL STUDIO .............................................................................................................. 8
4. .NET CORE 3.0, .NET 4.8 y VISUAL STUDIO 2019...................................................................................... 11
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 2
|Equipo Docente de .NET y Visual Studio
INTRODUCCIÓN
Doce años después del lanzamiento del primer .NET framework, el uso del marco de trabajo de .NET estaba
fragmentado en versiones diferentes para diferentes plataformas. Desde .NET Compact Framework hasta las
aplicaciones Silverlight, Windows Phone y Windows Store, cada vez que Microsoft incorporaba a .NET en
una nueva plataforma. El tiempo de ejecución de lenguaje, que supuestamente era "común", se había
terminado convirtiendo en subconjuntos diferentes. Microsoft trató de abordar este problema mediante la
introducción de bibliotecas de clases port átiles, proyectos compartidos y, por último, el UWP. El concepto
central de los dos primeros enfoques fue la idea de contrato, o en otras palabras, una forma de abstraer las
API para que pudieras usarse como si fueran las mismas para cada plataforma. Estos enfoques terminaron
convirtiéndose en estándar de facto en los desarrollos de aplicaciones modernas, y una vez que apareció
Xamarin, permitió llevar la idea aún más lejos al permitirnos reutilizar nuestro código en otras plataformas
como iOS, Android y Mac OS X. Desafortunadamente, en cada caso, la implementación de esas API fue
diferente, lo que provocaba que la resolución no fuera completa. Las bibliotecas de clases portátiles lograron
acercar las plataformas, pero simplemente no fueron capaces de hacer que el .NET Framework fuera más
modular. Otro problema es la compatibilidad con versiones anteriores entre diferentes versiones del marco,
incluso en la misma plataforma. Si, por ejemplo, se incluye una interfaz o una sobrecarga a un método se
plantea si el cambio causa o no algún problema en las aplicaciones existentes.
Con el fin de encontrar una manera de superar estas limitaciones (modularidad y compatibilidad con
versiones anteriores), Microsoft comenzó a distribuir algunos componentes de .NET Framework como
paquetes independientes en NuGet (biblioteca de colecciones inmutables), permitiendo a las personas usarlo
y proporcionar comentarios. Esto empezó teniendo un gran éxito; cada vez que la API llegaba a la versión
final, terminaba teniendo un mejor diseño. Y siguiendo esta aproximación de compartir para mejorar,
Microsoft puso a disposición de la comunidad de desarrolladores un núcleo del entorno .NET que denominó
.NET Core: una plataforma abierta, multiplataforma y de código abierta para modernizar los sistemas
Windows.
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 3
Introducción al Visual Studio
1. INTRODUCCIÓN
Como comentamos en la vista general del entorno .NET, el esquema general del marco de trabajo
responde:
FIGURA [Link]ÓN GENERAL DE .NET CORE EN .NET
Como se puede ver en la Figura 1, y hemos visto en todo el módulo 1, el panorama .NET incluye varios
modelos de aplicaciones que están agrupados dentro de una pila de tecnología específica. Sin considerar
Xamarin (que por sí solo requiere otro curso completo), nos quedamos con dos grupos principales: .NET
Framework completo y .NET Core. Ambos se ubican en la biblioteca estándar de .NET y comparten una
infraestructura común que incluye todas las tecnologías que conforman el compilador, los lenguajes y los
componentes de tiempo de ejecución. [Link] está presente en ambos grupos; sin embargo, existe una
diferencia sustancial entre los dos: la versión, o quizás el tipo, de .NET Framework que utiliza el tiempo de
ejecución. [Link] Core se ejecuta utilizando la versión multiplataforma de .NET Framework, que es el
tema de este capítulo, mientras que [Link] usa el completo .NET Framework.
La implementación en tiempo de ejecución de .NET Core se llama CoreCLR. El CoreCLR es un término único
que agrupa todas las tecnologías que son fundamentales para el tiempo de ejecución, como son RyuJIT, el
recolector de basura .NET, la interoperabilidad nativa y muchos otros componentes. El CoreCLR es
multiplataforma, para varios sistemas y multiproceso. Al ser de código abierto, se puede encontrar el
repositorio oficial aquí.
RyuJIT es el compilador Just‐In‐Time (JIT) [Link]. Core. Es mucho más rápido que el JIT de 64 bits JIT64
existente que se ha utilizado durante los últimos 10 años (introducido en la versión 2005 .NET 2.0).
Siempre hubo una gran brecha en el rendimiento entre los JIT de 32 y 64 bits. RyuJIT se integra de manera
similar en .NET Core como el JIT de 64 bits. Este nuevo JIT es dos veces más rápido, lo que significa que las
aplicaciones compiladas con RyuJIT se inician hasta un 30 por ciento más rápido. RyuJIT se basa en la
misma base de código que el JIT x86, y en el futuro será la base de todo el JIT de Microsoft: x86, ARM,
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 4
|Equipo Docente de .NET y Visual Studio
MDIL y cualquier otra cosa que surja. Al tener una base de código única significa que los programas .NET
son más consistentes entre las arquitecturas, y es mucho más fácil introducir nuevas características.
El compilador de .NET Core se denomina Roslyn. Roslyn consta de dos capas principales de API: las API de
compilador y las API de áreas de trabajo. La capa del compilador contiene los modelos de objetos que se
corresponden con la información expuesta en cada fase de la tubería de pasos que da el compilador, tanto
sintáctica como semántica. La capa del compilador también contiene una instantánea inmutable de una
sola invocación de un compilador, incluidas las referencias de ensamblaje, las opciones del compilador y
los archivos de código fuente. La capa de espacios de trabajo contiene la API del espacio de trabajo, que es
el punto de partida para realizar análisis de código y refactorización de soluciones completas. Esta capa no
tiene dependencias en los componentes de Visual Studio. De hecho, incluso Visual Studio Code, el IDE tipo
Visual Studio gratuito y de plataforma X, utiliza Roslyn para proporcionar una experiencia de desarrollo
enriquecida a los desarrolladores de C#.
.NET Core es un nuevo motor de ejecución, modular y enriquecido con un subconjunto de la parte de API
de .NET Framework. .NET Core se puede dividir en dos secciones principales: una llamada CoreFX, que
consiste en un pequeño conjunto de bibliotecas, y una llamada CoreCLR, un tiempo de ejecución pequeño
y optimizado. .NET Core es uno de los proyectos de Microsoft bajo la administración de la Fundación .NET,
lo que significa que es (y será) de código abierto, y todos podemos contribuir y seguir su progreso. Con el
objetivo de mantener la modularidad, Microsoft ha optado por distribuir el tiempo de ejecución CoreCLR y
las bibliotecas CoreFX en NuGet, factorizándolas como paquetes individuales de NuGet. Los paquetes
llevan el nombre de su espacio de nombres para facilitar su descubrimiento durante la búsqueda. Uno de
los beneficios clave de .NET Core es su portabilidad. Se puede empaquetar e implementar CoreCLR con su
aplicación, eliminando la dependencia de su aplicación en una versión instalada de .NET. Se puede alojar
varias aplicaciones en paralelo utilizando diferentes versiones de CoreCLR y actualizarlas individualmente,
en lugar de tener que actualizarlas todas simultáneamente. CoreFX se ha creado como un conjunto de
bibliotecas con componentes, cada una de las cuales requiere el conjunto mínimo de dependencias de la
biblioteca. Este enfoque permite distribuciones mínimas de bibliotecas CoreFX (solo las que necesita)
dentro de una aplicación, junto con CoreCLR.
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 5
Introducción al Visual Studio
2. USO DE .NET CORE
2.1. INSTALACIÓN DE .NET CORE
.NET Core se instala en diferentes cargas de trabajo de Visual Studio. Por una parte, se integra entre los
elementos fundamentales de .NET y además aparece como “Desarrollo multiplataforma de .NET Core”.
También podemos descargarlo para las diferentes plataformas con instaladores separados:
FIGURA 2. DESCARGA DE INSTALADORES PARA WINDOWS, LINUX y MacOS DE .NET CORE
Podemos comprobar las versiones de .NET Core que estamos manejando en nuestro entorno con una
línea de comandos llamando a “dotnet –info”:
FIGURA 3. DOTNET ‐‐INFO
Desde la misma línea de comandos podemos realizar un proyecto de programa con .NET utilizando la
llamada a “dotnet new” y alguna de las plantillas por defecto que tenemos disponible:
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 6
|Equipo Docente de .NET y Visual Studio
Plantilla Nombre corto Lenguaje Etiqueta
Console Application console [C#], F#, VB Common/Console
Class library classlib [C#], F#, VB Common/Library
Unit Test Project mstest [C#], F#, VB Test/MSTest
NUnit 3 Test Project nunit [C#], F#, VB Test/NUnit
NUnit 3 Test Item nunit‐test [C#], F#, VB Test/NUnit
xUnit Test Project xunit [C#], F#, VB Test/xUnit
Razor Page Page [C#] Web/[Link]
MVC ViewImports viewimports [C#] Web/[Link]
MVC ViewStart viewstart [C#] Web/[Link]
[Link] Core Empty web [C#], F# Web/Empty
[Link] Core Web App Mvc [C#], F# Web/MVC
Por ejemplo, si hacemos “dotnet new console”, se crea un programa “[Link]” y un proyecto
“[Link]” que se enlaza con el marco .NET Core 2:
FIGURA 4. DOTNET NEW
Para un programa “Hola mundo”:
using System;
namespace temp
{
class Program
{
static void Main(string[] args)
{
[Link]("Hello World!");
}
}
}
Para poder ejecutar el ejemplo es necesario utilizar el comando “dotnet run”.
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 7
Introducción al Visual Studio
FIGURA 5. DOTNET RUN
3. .NET CORE CON VISUAL STUDIO
Desde la aparición de .Net Core, el marco ha quedado disponible en Visual Studio para el desarrollo de
aplicaciones basadas en él. Las tres principales plantillas que proporciona el entorno son:
Aplicación de consola de .Net Core.
Biblioteca de clases de .Net Core.
Aplicación de [Link] Core.
Según la versión de Visual Studio podemos disponer de otras opciones relacionadas con el desarrollo de
pruebas unitarias con MSTest, Nunit o XUnit.
FIGURA 6. PLANTILLAS .NET CORE EN VISUAL STUDIO 2017
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 8
|Equipo Docente de .NET y Visual Studio
Si creamos un proyecto de consola nuevo la solución incorpora la dependencia al SDK de la versión de .Net
Core configurada en Visual Studio:
FIGURA 7. SOLUCIÓN DE .NET CORE PARA APLICACIÓN DE CONSOLA
Si utilizamos el entorno en Mac OS, las opciones son similares:
FIGURA 8. PLANTILLAS .NET CORE EN VISUAL STUDIO PARA MAC
Entre estas plantillas resuelta especial las opciones que disponemos para la realización de aplicación con
[Link] Core. Al seleccionar este tipo de plantilla el entorno nos ofrece diferentes opciones para
desarrollar aplicaciones web con los distintos motores:
Razor (usado por defecto por parte de Microsoft).
Angular
[Link]
Redux
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 9
Introducción al Visual Studio
FIGURA 9. PLANTILLAS [Link] CORE
Que genera la aplicación:
FIGURA 10. WEB APP CON [Link] CORE RAZOR
Por último, y a modo de resumen actual (en las próximas versiones de .NET Core las cosas irán cambiando)
podríamos fijar que el uso de .NET es recomendable en caso de aplicaciones:
Multiplataforma, que funcione en varios sistemas con un único código (sin código de plataforma).
Basadas en arquitectura de microservicios (ASP .NET Core es la mejor solución).
Sistemas escalables y con altas necesidades de rendimiento.
Desarrollos para línea de comandos que funcionen en Windows, Mac y Linux.
Si necesitas usar varias versiones de .NET "side by side" en un mismo desarrollo (juntos pero no
revueltos).
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 10
|Equipo Docente de .NET y Visual Studio
Aplicaciones Universales de Windows 10 (UWP), que usan .NET Core por debajo.
No usaremos .NET Core y preferimos .NET si las aplicaciones:
Son actuales que ya estén funcionando. Puedes intentar una migración, pero... va a ser
complicada.
Son nuevas aplicaciones de tipo monolítico, es decir, aquellas que no están diseñadas para ser
disgregadas en pequeños componentes independientes (estilo microservicios). No es tanto porque
se tenga la obligación de usar este tipo de arquitectura, sino porque casi con seguridad se va a
encontrar que es necesario usar componentes de .NET tradicional no soportados en .NET Core
(por ejemplo, hasta la versión 3.0 no tendremos soporte de las Windows Presentation
Foundation).
Depende de alguna API no portada a .NET Core, y ¡hay muchas!
4. .NET CORE 3.0, .NET 4.8 y VISUAL STUDIO 2019
Los anuncios de Microsoft a lo largo del año 2018, han fijado el lanzamiento de Visual Studio 2019 con
.NET 4.8 y de .NET Core 3.0 a lo largo del primer semestre del año 2019. Una de las mejoras más
importantes será la compatibilidad con las aplicaciones de Escritorio de Windows (solo Windows).
Mediante el uso de un componente de .NET Core 3.0 denominado "Escritorio de Windows", se podrá
convertir las aplicaciones de Windows Presentation Foundation (WPF) y Windows Forms desde el .NET
Standard al .NET Core.
Las tres ventajas fundamentales que incorporará .NET Core 3.0, pueden resumirse en:
.‐ Versiones paralelas de .NET que admiten WinForms y WPF: .NET Framework incorpora un única
versión por máquina; mientras que .NET Core permite resolver múltiples versiones de .NET Core en la
misma máquina.
.‐ .NET embebido en las aplicaciones: como solo puede haber una versión de .Net framework en la
máquina, si los desarrolladores quieren aprovechar la última versión o la última funcionalidad, es
importante instalar una versión más nueva. .NET Core permite aprovechar la última versión, funcionalidad
y API sin tener que esperar a que se instale el marco.
.‐ Aprovechar las características principales de .NET: .NET Core es una versión de código abierto
que permite introducir nuevas API sin encontrar problemas de compatibilidad.
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 11
Introducción al Visual Studio
UNIVERSIDAD NACIONAL DE EDUCACIÓN A DISTANCIA 12