El punto de entrada de una aplicación en asp.net core 2 se hace a través de la clase Program.cs donde ejecuta el método Main() para configurar el ambiente y apuntar a la clase que será la encargada de establecer la configuración de nuestra aplicación.

El contenido de la clase Program.cs que viene por defecto cuando iniciamos un proyecto asp.net core 2 en visual studio es suficiente para correr e iniciar nuestra aplicación.

Código por defecto de la clase Program.cs

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();
}

El método Main() provee el punto de entrada que permite ser ejecutado por el .NET runtime donde llama al método BuildWebHost() para configurar asp.net core. 

Métodos que ejecuta BuildWebHost

Por defecto BuildWebHost ejecuta tres métodos

  • CreateDefaultBuilder: configura asp.net core usando parámetros que se adaptan a la mayoría de los proyectos.
  • UseStartup: identifica que clase provee de la configuración especifica de la aplicación.
  • Build: procesa toda la configuración y crea un objeto que implementa la interfaz IWebHost.

El método CreateDefaultBuilder es la manera recomendada de comenzar con un proyecto de asp.net core. La implementación completa de este método se puede observar en el siguiente link de github

En el siguiente código, se muestra algunos de los métodos que utiliza

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) {
        return new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .ConfigureAppConfiguration((hostingContext, config) => {
                var env = hostingContext.HostingEnvironment;
                config.AddJsonFile("appsettings.json", true, true)
                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", true, true);

                config.AddEnvironmentVariables();
            })
            .ConfigureLogging((hostingContext, logging) => {
                logging.AddConfiguration(
                    hostingContext.Configuration.GetSection("Logging"));
                logging.AddConsole();
                logging.AddDebug();
            })
            .UseIISIntegration()
            .UseDefaultServiceProvider((context, options) => {
                options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
            })
            .UseStartup<Startup>()
            .Build();
    }
}
  • UseKestrel: Configura el servidor web Kestrel
  • UseContentRoot: Configura el directorio raíz para nuestra aplicación en cual se van a utilizar los archivos de configuración y contenido estático como por ejemplo imágenes y archivos de javascript/css.
  • ConfigureAppConfiguration: Permite establecer información de configuración para cada ambiente a través del uso de archivos JSON, variables de ambientes y argumentos de consola.
  • ConfigureLogging: Permite configurar el sistema de registros (logs) para nuestra aplicación. 
  • UseIISIntegration: Activa la integración del IIS y el IIS Express.
  • UseDefaultServiceProvider: Permite configurar la inyección de dependencias.
  • UseStartup: Especifica la clase utilizada para configurar nuestra aplicación asp.net.

La sintaxis básica para ejecutar correctamente nuestra aplicación es la siguiente

public static IWebHost BuildWebHost(string[] args)
{
    return new WebHostBuilder()
        .UseKestrel()
        .UseContentRoot(Directory.GetCurrentDirectory())
        .UseIISIntegration()
        .UseStartup<Startup>()
        .Build();
}

La clase Startup

La configuración mas importante para nuestra aplicación se encuentra en el método UseStartup<Startup>(). El nombre convencional para esta clase es Startup

El contenido de esta clase es el siguiente

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc();
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseBrowserLink();
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
        }

        app.UseStaticFiles();

        app.UseMvc();
    }
}

Define dos métodos, ConfigureServicesConfigure. 

Al iniciar la aplicación ASP.NET Core llama a ConfigureServices para crear los servicios que van a ser utilizados dentro de nuestra aplicación. Una vez que los servicios fueron creados, ASP.NET llama al método Configure para establecer el tubo (pipeline) que esta compuesto por un conjunto de componentes (middleware) para manejar las solicitudes http que llegan hacia nuestra aplicación.  

Cuando hablamos de servicios, estamos hablando de objetos que proveen funcionalidad a otras partes de nuestra aplicación. 

Mas adelante, veremos a mayor profundidad acerca de la clase Startup.

¡Si te gusto el articulo, compártelo con tus contactos en las redes sociales!

Escribe una respuesta a este comentario

avatar
500
  Subscribe  
Notificar de