DEV Community: Leonardo Hidrovo

Agregando la clase Startup en ASP.NET Core 6.

Leonardo Hidrovo — Wed, 01 Dec 2021 02:12:02 +0000

En noviembre del 2021, .NET 6 se convierte oficialmente en el nuevo framework de Microsoft el cual nos permite desarrollar aplicaciones que abarcan distintas áreas para direfentes plataformas. Una de esas áreas es la web con ASP.NET Core.

ASP.NET Core en .NET 6 incluye algunas novedades. Una de ellas, es la nueva forma de configurar el punto de partida de las aplicaciones web.

Hasta ASP.NET Core 5, el lugar elegido para escribir código de inicialización era en una clase llamada Startup. Aquí se configuraban algunos aspectos como los middlewares y la inyección de dependencias. Esta clase debía cumplir con ciertos requisitos para que el framework de ASP.NET Core pueda ejecutarse sin problemas.

Nuevo modelo de configuración.

El nuevo enfoque de configuración en ASP.NET Core 6 es llamado "modelo de hosting mínimo" donde se unifica los archivos Startup.cs y Program.cs en un único archivo Program.cs.

Al momento de crear una aplicación ASP.NET Core 6, nos damos cuenta de que el archivo Startup.cs no existe. Es el archivo Program.cs el que contiene todo el código de inicialización, inyección de dependencias, y configuración del HTTP request pipeline también conocido como midleware.

Reviviendo la clase Startup en el nuevo modelo de hosting mínimo.

Personalmente creo que la clase Startup tenía gran valor porque nos permitía mantener por separado y mejor organizado la configuración de los servicios y los midlewares. A continuación veremos cómo podemos traerla de vuelta.

Antes de empezar, debemos de comprobar que tenemos instalado la versión más reciente del .NET 6. Podemos utilizar el siguiente comando en la terminal de cualquier plataforma (Windows, Linux, MacOS).

~$ dotnet --version

Si no lo tenemos instalado, podemos descargar el SDK aquí.

Como segundo paso, vamos a crear un proyecto en ASP.NET Core 6. En este ejemplo, crearemos una aplicación Web API. Podemos crearla utilizando Visual Studio 2022 o mediante la línea de comandos con el dotnet CLI como veremos a continuación.

~$ dotnet new wepapi -o WebApi6

Este comando nos crea un proyecto de ASP.NET Core Web API en la carpeta WebApi6 el cuál también será el nombre del proyecto utilizando el framework .NET 6.

Luego, crearemos un archivo llamado Startup.cs en la raíz de nuestro proyecto.

Con nuestro archivo Startup creado, vamos agregar código de forma similar a lo que ya teníamos en las versiones anteriores.

Agregamos un constructor que recibe como parámetro el IConfiguration que nos permitirá leer configuraciones de distintos orígenes en el formato clave-valor. También agregamos un método void llamado ConfigureServices que recibe como parámetro el IServiceCollection. Esta interfaz nos permitirá hacer uso del principio de inversion de dependencias, donde podemos hacer que nuestras clases dependan de abstracciones y no tipos concretos.
Por último un método Configure donde recibirá IApplicationBuilder y IWebHostEnvironment como parámetros. Este método también es de tipo void.

Ahora, vamos a hacer un refactor de nuestro archivo Program.cs. El código relacionado a la configuración de los servicios lo movemos al método ConfigureServices de la clase Startup y reemplazamos builder.Services por services.

Archivo Program.cs

Archivo Startup.cs

Luego, movemos la sección del código referente a la configuración del HTTP request pipeline hacia el método Configure de la clase Startup.

Archivo Program.cs

Archivo Startup.cs

Después de copiar el código al método Configure, nuestro editor nos mostrará unos errores, por lo que tendremos que hacer un pequeño refactor tal como se muestra en la imagen de arriba.

¡Ahora el código de la clase Program quedó más compacto!

Por último, es necesario utilizar nuestra clase Startup en la clase Program. Para ello, vamos a instanciarla pasándole como parámetro builder.Configuration. Luego, llamaríamos al método ConfigureServices enviándo como parámetro builder.Services. Después de construir la applicación con var app = builder.Build();, invocamos al método Configure donde pasamos como parámetros a app y app.Environment. Nuestro código quedaría finalmente así en la clase Program.

Conclusión.

A pesar de que ASP.NET Core 6 no nos proporciona la clase Startup, hemos visto un modo de cómo agregarla. Cabe mencionar que este proceso no es requerido. Es sólo una forma de cómo mantener nuestro código organizado y también puede ser de ayuda si estamos migrando desde versiones anteriores de ASP.NET Core.

Referencias:

Iniciando en Blazor

Leonardo Hidrovo — Fri, 20 Aug 2021 14:54:19 +0000

¿Imaginas utilizar un lenguaje de programación de back-end como .NET en el lado del cliente?

Anteriormente, cuando queríamos crear aplicaciones web que corrieran en un navegador, debíamos utilizar JavaScript como lenguaje de programación ya sea puro o utilizando algún framework como React, Angular, JQuery, entre otros. Con WebAssembly podemos utilizar otros lenguajes de programación y gracias a Blazor podemos utilizar de forma cómoda código de C# que será ejecutado en el navegador.

1. ¿Qué es Blazor?

Es un framework que nos permite crear aplicaciones web del lado del cliente usando C# como lenguaje de programación utilizando un paradigma de componentes. Estas aplicaciones se ejecutan en el lado del navegador gracias a WebAssembly.

2. ¿Qué es WebAssembly?

WebAssembly o también conocido como Wasm es un estándar web que define un formato de ensamblaje para código ejecutable en navegadores web. Esta tecnología nos permite compilar el código de otros lenguajes en WebAssembly para facilitar su ejecución en el navegador a una velocidad casi nativa. En el caso de Blazor, podremos ejecutar aplicaciones .NET en el navegador. Esto es posible porque compilamos el runtime de .NET en WebAssembly. Esto permite utilizar cualquier librería de back-end (.dll) en el front-end siempre y cuando sea compatible con .NET Standard. Sin embargo, para que Wasm pueda funcionar, el navegador debe ser compatible con este lenguaje. La mayoría de los navegadores web modernos lo son. Podemos ver la compatibilidad en el siguiente enlace: https://caniuse.com/wasm

Pero ¿Y si se deseamos utilizar JavaScript?, ¡Blazor lo tiene cubierto! Viene con interoperabilidad de JavaScript. Con JS Interop, una aplicación Blazor puede invocar funciones JavaScript desde métodos .NET y métodos .NET desde funciones JavaScript.

3. Modelos de alojamiento

Para ejecutar aplicaciones Blazor tenemos dos modos: Blazor en el lado del cliente (Blazor WebAssembly) y Blazor en el lado del servidor (Blazor Server).

Blazor en el lado del cliente:

En esta opción, la aplicación de Blazor corre en el navegador gracias a WebAssembly quitando esa carga al servidor. La desventaja podría ser la descarga inicial que puede ser de varios megas dependiendo de la aplicación.
Blazor en el lado del servidor:

Con esta opción, la aplicación de Blazor corre en el servidor web y el cliente interactúa con ella a través de una conexión de SignalR manejando de esta forma comunicación en tiempo real. Con esto se logra que el usuario interactúe con la aplicación de manera remota. Como ventaja tenemos que dispositivos con menos recursos pueden correr la aplicación sin problemas. Las limitaciones es que siempre debemos tener un servidor disponible para las interacciones con el usuario y puede haber latencia si la conexión de internet no es buena o si los recursos del servidor son limitados.

4. ¿Por qué usar Blazor?

Con Blazor podemos aprovechar todas nuestras habilidades en .NET y comenzar a trabajar en el desarrollo web con sólo un poco de trabajo y conocimiento adicional, permitiendo acelerar el proceso de desarrollo de manera significativa.

5. Creando una aplicación de Blazor

Antes de empezar a crear aplicaciones .NET, necesitamos tener descargado el .NET SDK (Software Development Kit). El link de descarga es para usuarios de MacOS aunque también están las opciones para Linux y Windows.

Una vez que lo hayamos instalado, abrimos la terminal y ejecutamos el siguiente comando:

~$ dotnet

Si la instalación se realizó correctamente, deberíamos de ver un resultado similar al siguiente:

Usage: dotnet [options]
Usage: dotnet [path-to-application]

Options:
-h|--help         Display help.
--info            Display .NET information.
--list-sdks       Display the installed SDKs.
--list-runtimes   Display the installed runtimes.

path-to-application:
The path to an application .dll file to execute.

Luego ejecutamos el siguiente comando para crear la aplicación Blazor WebAssembly llamada BlazorApp

~$ dotnet new blazorwasm -o BlazorApp --hosted

El argumento --hosted es opcional y en este caso nos crea adicionalmente un Web API en ASP.NET Core que nos permite servir datos a nuestra aplicación Blazor.

Ahora, navegamos al nuevo directorio BlazorApp creado por el comando anterior:

~$ cd BlazorApp

Luego escribimos el comando code . para abrir el directorio actual en Visual Studio Code. Este paso es opcional, podemos utilizar cualquier editor de código de nuestra preferencia.

~$ code .

Finalmente ejecutamos el comando:

~$ dotnet watch run

El comando dotnet watch run compilará e iniciará la aplicación, y luego recompilará y reiniciará la aplicación cada vez que realicemos cambios en el código. Podemos detener la aplicación en cualquier momento seleccionando Ctrl + C.

Una vez que nuestro navegador se inicie, habremos ejecutado con éxito nuestra primera aplicación Blazor.

6. Conclusión

Debemos recordar que Blazor es todavía una tecnología en desarrollo y como tal necesita evolucionar. A pesar de que está creciendo rápidamente y se está convirtiendo en una buena opción, no reemplaza a las tecnologías actuales ni quedarán obsoletas debido a Blazor, por lo que podemos seguir usándolas con tranquilidad.

Referencias:

https://docs.microsoft.com/en-us/aspnet/core/blazor/?view=aspnetcore-5.0
https://dotnet.microsoft.com/learn/aspnet/blazor-tutorial