¿Explicar ConfigureServices y el método Configure en ASP.NET?

En este artículo, veremos qué son los métodos Configure y ConfigureService. Básicamente, estos dos métodos juegan un papel muy importante en la clase de inicio. La línea de base de esta clase es reducir la dependencia de la aplicación en el servidor. En realidad, se requiere la clase Startup para definir dos métodos que ASP.NET Core invocará automáticamente. Son el método ConfigureServices y el método Configure.  

En la clase Startup, en realidad hacemos dos cosas:

• Configure Service(): se utiliza para agregar servicios al contenedor y configurar esos servicios. básicamente, el servicio es un componente que está destinado al consumo común en la aplicación. Hay un servicio de marco como MVC, EF core, identidad, etc. pero también hay servicios de aplicaciones que son específicos de la aplicación, como los servicios de envío de correo.
• Configure(): se usa para especificar cómo la aplicación principal de asp.net responderá a las requests individuales. A través de esto, en realidad construimos la tubería de solicitud HTTP

Ejemplo: Abra el archivo program.cs. Como se puede ver el código:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
  
namespace Avengers_ListApplicaton {
    public class Program {
        public static void Main(string[] args) {
            CreateHostBuilder(args).Build().Run();
        }
  
        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup> ();
            });
    }
}

• En la función principal, se configura un host, que configurará un servidor y una canalización de procesamiento de requests.
• Estamos llamando a CreateHostBuilder , que configurará una aplicación con algunos valores predeterminados usando Host.CreateDefaultBuilder().
• En Main, llamaremos a CreateHostBuilder , y allí se creará un host que luego ejecutará nuestra aplicación. Puede ver que primero vamos a llamar al host el método CreateDefaultBuilder . El método CreateDefaultBuilder configurará un generador de host con bastantes valores predeterminados. el nuevo servidor web se configurará nuevamente con los valores predeterminados.
• Otra cosa muy importante que sucede aquí es que estamos especificando la clase Startup usando el método UseStartup . Estamos pasando como tipo la clase Startup, es decir, UseStartup<Startup> , que será el tipo que realmente realice la configuración de la aplicación.

Startup.cs: echemos un vistazo a la clase Startup. como vemos los ConfigureServices y el método Configure .

namespace Avengers_ListApplicaton {
    public class Startup {
        
        // This method gets called by the runtime. 
          // Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services) {
            // Register services here through dependency injection
        }
  
        // This method gets called by the runtime. 
          // Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, 
                              IWebHostEnvironment env) {
            
            // Add middlware components here
            if (env.IsDevelopment()) {
                app.UseDeveloperExceptionPage();
            }
            app.UseRouting();
            app.UseEndpoints(endpoints => {
                endpoints.MapGet("/",async Context => {
                    await context.Response.WriteAsync("Hello World!");
                });
            });
        }
    }
}

En el método ConfigureServices:

• En el método ConfigureServices, que será llamado primero, estaremos registrando nuestros servicios para la aplicación
• Como puede ver, en el fragmento de código anterior inicialmente no hay código en ConfigureService, pero independientemente de eso, esos servicios integrados ya están disponibles para inyección, por lo que todos los servicios que podemos agregar en este método e inyectar en otras piezas de código.
• Este contenedor está disponible a través de la interfaz IServiceProvider y la colección de servicios que ve aquí es la colección de servicios que administra. Entonces podemos, en el método ConfigureServices, agregar los servicios a la colección de servicios administrados en la aplicación. Los servicios son objetos con funcionalidad fija para otras partes de la aplicación.
• Allí, debemos agregar todos los servicios que usaremos dentro de nuestra aplicación. Esos pueden ser servicios incorporados, así como nuestros propios servicios. Este es el lugar donde registraremos todas las dependencias con el sistema de inyección de dependencia integrado en ASP.NET Core.

En el método Configurar:

Este se llama después de configurar el método de servicio porque utiliza servicios que están registrados y configurados en el método configureServices

• Se configurará la canalización de requests HTTP. Hay algunos valores predeterminados aquí, como puede ver, y observe que la primera línea usará una verificación de entorno. Usando la inyección de dependencia, este método recibirá una instancia de WebHostEnvironment , y en eso, vamos a verificar el entorno.
• El env.IsDevelopment Esto significa que este middleware de página de excepción fácil de usar para desarrolladores solo se agregará cuando estemos ejecutando en un entorno de desarrollo. El middleware developerExceptionPage no es algo que queremos que todos vean. queremos apilar rastros de excepción solo durante la aplicación de desarrollo. La declaración UseDeveloperExceptionPage configura la canalización de solicitud al agregarle el middleware developerExceptionPage, de modo que ahora, cuando se lanza una excepción, el fragmento de código que ve en el fragmento de código lo manejará.
• Ahora voy a agregar otra pieza de código que maneja las excepciones que no pertenecen al entorno de desarrollo. El middleware useExceptionHandler detecta la excepción, la registra y luego vuelve a ejecutar la solicitud. Esto no nos mostrará una página de excepción amigable para el desarrollador y el seguimiento de la pila no estará expuesto. Ahora puede verificar cambiando la variable de entorno.
• bueno, pasemos al siguiente UseRouting y UseEnpoints . En realidad, es responsable de dar la respuesta como salida cuando se envió una solicitud a la aplicación que iba a responder enviando a la respuesta una string que decía ‘Hola mundo’ para que los middlewares de enrutamiento y puntos finales usados Básicamente, permite que MVC responda a una solicitud entrante, necesita asignar las requests entrantes con el código correcto que se ejecutará.

Veamos ahora cómo decorar los servicios en el archivo startup.cs. Cree un proyecto simple,

En este proyecto, no voy a explicar o definir todos y cada uno de los pasos. En el que nos vamos a centrar solo en el archivo startup.cs

Entonces empecemos:

Paso 1: cree un nuevo proyecto de aplicación web principal de asp.net y seleccione la plantilla MVC

Paso 2: cree una clase de modelo en la carpeta del modelo, es decir, ToDoModel

public class ToDoModel {
    public int Id { get; set; }
    [Required]
    [MaxLength(50)]
    public string Wish{ get; set; }
}

Paso 3: Crear clase ApplicationDbContext | Hereda la clase DbContext | Agregar constructor | Agregar clase de modelo a ApplicationDbContext

public class ApplicationDbContext : DbContext {
    public ApplicationDbContext(
          DbContextOptions<ApplicationDbContext> options)
             : base(options) {
    }
         
    public DbSet<ToDoModel> ToDoData { get; set; }
}

Nota: En esta demostración, usaré la base de datos InMemory con Entity Framework Core. Por lo tanto, debe instalar el paquete nuget, es decir, Microsoft.EntityFrameworkCore.InMemory.

Paso 4: Ahora registremos los servicios en el método ConfigureServices, 

• llame a AddMvc() para agregar soporte para el middleware MVC.
• llame a AddDbContext<> con el argumento de .UseInMemoryDatabase(“ToDoList”) para configurar EntityFramework en la clase DbContext.

public void ConfigureServices(IServiceCollection services) {
      services.AddMvc();
    services.AddDbContext<ApplicationDbContext>(
        options => options.UseInMemoryDatabase("ToDoList"));
}

Paso 5: en el método Configure, elimine el código existente por completo y reemplácelo con una llamada a app.UseRouting() y, después de UseRouting, agregue una llamada a app.UseEndpoints().

UseRouting: este componente de Middleware se utiliza para enrutar requests.

UseEndpoints: este componente de middleware permitirá enrutar la solicitud al punto final correcto en la aplicación. 

public void Configure(IApplicationBuilder app, 
                      IWebHostEnvironment env) {
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    }
    else {
        app.UseExceptionHandler("/Home/Error");
    }
    app.UseRouting();
  
    app.UseEndpoints(endpoints => {
        endpoints.MapDefaultControllerRoute();
    });
}

Paso 6: en el método Configure antes de UseRouting, verifica el entorno si env está configurado en Development usando el método IsDevelopment() 

• En caso afirmativo, debe llamar a app.UseDeveloperExceptionPage() para obtener el seguimiento de la pila de las páginas de error.
• De lo contrario, debería llamar a app.UseExceptionHandler() y pasarle el argumento “/Home/Error”
• UseDeveloperExceptionPage: Esto habilitará el uso de la página de excepción del desarrollador en mi aplicación, por lo que obtendrá información útil durante el desarrollo.
• UseExceptionHandler: este componente de middleware se usa para habilitar la adición de mensajes de error personalizados fáciles de usar.

Paso 07: Crear controlador HomeController | Agregue métodos de acción, es decir, índice y error |

public class HomeController : Controller {
    public IActionResult Index() {
        return View("Index");
    }
    public IActionResult Error() {
        return View("Error");
    }
}

Paso 08 : en la carpeta compartida, cree una vista de error genérica y también para agregar una vista al método de índice | En esa vista de índice, agregue el enlace de ToDoList

Método de acción de error Ver:

@{
    ViewData["Title"] = "Error";
}
  
<h1>Error</h1>
  
  
<p>An error has occurred. Please try again.</p>

Método de acción de índice de la vista Homecontroller:

@model IEnumerable<ToDoList.Models.ToDoModel>
  
@{
    ViewData["Title"] = "Index";
}
  
<h1>Index</h1>
  
@Html.ActionLink("View Task List", "Index", "ToDo")

Paso 9: Crea un controlador más | crear un campo de tipo ApplicationDbContext. | Crear constructor y establecer el valor del parámetro pasado al constructor | Crear métodos de acción para la lista | Obtener Crear | Publicar Crear y en base a ello agregar vistas 

public class ToDoController : Controller
    {
        private readonly ApplicationDbContext _context;
  
        public ToDoController(ApplicationDbContext context)
        {
             _context = context;
        }
        public IActionResult Index()
        {
            var model=_context.ToDoData.ToList();
            return View("Index",model);
        }
        [HttpGet]
        public IActionResult Create()
        {
            return View("Create");
        }
        [HttpPost]
        public IActionResult Create(ToDoModel todo)
        {
            _context.ToDoData.Add(todo);
            _context.SaveChanges();
            return RedirectToAction("Index");
        }
         
    }

Producción:

GIF de salida

último pensamiento,

Flujo de inicio de la aplicación

Vamos a resaltar rápidamente algunos puntos del artículo. La aplicación comienza con la llamada a la función principal en la clase Startup. Luego, especificamos cuál era nuestra clase de inicio usando la llamada de inicio. En la clase Startup, primero se llama a ConfigureServices, lo que nos permite registrar los servicios que querremos usar en nuestra aplicación. Luego, se llama al método Configure donde se configura la canalización de solicitud. Después de todo eso, nuestra aplicación está funcionando y lista para manejar las requests entrantes.

Eso es todo acerca de los métodos Configure y ConfigureService.