Inicialização do aplicativo no ASP.NET Core

O Program ficheiro

As aplicações ASP.NET Core inicializam e configuram o arranque no ficheiro da Program aplicação (Program.cs).

A primeira parte do Program ficheiro foca-se na construção da aplicação. Esta fase utiliza WebApplication.CreateBuilder para inicializar uma nova instância da classe WebApplicationBuilder com predefinições antes de a aplicação ser iniciada. Os modelos de projeto ASP.NET Core atribuem o construtor de aplicações web a uma variável chamada builder:

var builder = WebApplication.CreateBuilder(args);

As propriedades do construtor de aplicações web incluem:

• builder.Configuration é um IConfigurationBuilder e IConfigurationRoot para gerir fontes de configuração e provedores. Para obter mais informações, consulte Configuração no ASP.NET Core.
• builder.Environment é um IWebHostEnvironment que fornece informações sobre o ambiente de alojamento web da aplicação. Para obter mais informações, consulte ASP.NET Core runtime environments.
• builder.Host é um IHostBuilder para configurar propriedades específicas do host. Para mais informações, consulte o Host Genérico do .NET no ASP.NET Core.
• builder.Logging é um ILoggingBuilder com métodos de extensão que adicionam e gerem fornecedores de registo. Para obter mais informações, consulte Logging no .NET e no ASP.NET Core.
• builder.Metrics(.NET 8 ou posterior) permite ativar métricas e direcionar a sua saída. Para obter mais informações, consulte ASP.NET Core métricas.
• builder.Services é um conjunto de serviços de injeção de dependências (DI) (IServiceCollection) que permitem à aplicação compor para Inversão de Controlo (IoC). Para mais informações, consulte Injeção de Dependências no ASP.NET Core.
• builder.WebHost é um IWebHostBuilder para configurar propriedades específicas do servidor.

A aplicação é construída ao chamar WebApplicationBuilder.Build, que devolve o WebApplication construído. Os modelos de projeto ASP.NET Core atribuem a aplicação web construída a uma variável chamada app:

var app = builder.Build();

A parte seguinte do ficheiro Program centra-se em configurar o pipeline de processamento de pedidos HTTP como uma série de componentes de middleware. Cada middleware realiza operações num HttpContext e ou invoca o middleware seguinte no pipeline ou termina o pedido. Por convenção, os componentes de middleware são adicionados ao pipeline invocando um método de extensão que começa por "Use." Para mais informações, consulte middleware ASP.NET Core.

O Run método inicia a aplicação e bloqueia a thread de chamada até que o host seja desligado:

app.Run();

Quando Run é executada, a aplicação transita para um processo ativo e em corrida:

1. Os serviços alojados iniciam-se.

   O anfitrião percorre todos os serviços alojados registados (instâncias de IHostedService) e chama os respetivos métodos StartAsync. A menos que a aplicação opte por iniciar um serviço alojado concorrente (.NET 8 ou posterior), os serviços alojados começam sequencialmente pela ordem dos registos dos contentores DI. Para mais informações, consulte Tarefas em segundo plano com serviços alojados no ASP.NET Core.

2. O pipeline de middleware é construído.

   Quando builder.Build é chamado, as dependências são resolvidas, mas o pipeline de processamento real não está completamente definido. Quando app.Run é executado, o framework finaliza o pipeline de middleware HTTP. Os métodos do middleware declarados e os mapeamentos de pontos finais são compilados numa única sequência de delegados de execução de elevado desempenho. Para mais informações, consulte middleware ASP.NET Core.

3. O servidor web (Kestrel por defeito) é iniciado.

   O host consulta dentro do seu contentor de dependência, localiza a implementação registada do servidor (normalmente Kestrel) e desencadeia o seu ciclo de arranque. Kestrel Depois:

   • Procura os URLs e portas de alojamento definidos a partir de configuração, variáveis de ambiente ou argumentos de linha de comandos.
   • Abre e aloca sockets físicos de rede.
   • Liga portas e começa a ouvir o tráfego que chega.

   Para mais informações, consulte .NET Generic Host em ASP.NET Core, implementações de servidores Web em ASP.NET Core e Kestrel o servidor Web em ASP.NET Core.

4. Os eventos do ciclo de vida da aplicação são acionados no arranque.

   O IHostApplicationLifetime serviço dispara o seu ApplicationStarted token, que invoca callbacks registados no token. Todos os callbacks, inicializadores da base de dados ou outros ouvintes de eventos personalizados configurados para aguardar que o token seja acionado são acionados para iniciar o processamento.

5. O fio principal de execução fica bloqueado enquanto a aplicação está a correr.

   Run (app.Run()) espera sincronizadamente até ao encerramento.

6. A aplicação está pronta para processar pedidos.

   Neste ponto, o interpretador de comandos regista os diagnósticos de alojamento:

   info: Microsoft.Hosting.Lifetime[14]
         Now listening on: https://localhost:7123
   info: Microsoft.Hosting.Lifetime[14]
         Now listening on: http://localhost:5123
   info: Microsoft.Hosting.Lifetime[0]
         Application started. Press Ctrl+C to shut down.
   

A aplicação mantém-se neste estado indefinidamente, passando o tráfego web recebido pelo pipeline do middleware e enviando respostas.

Quando é sinalizado o encerramento, por exemplo, quando Ctrl+c é detetado no shell de comandos onde a aplicação está em execução ou uma ferramenta de orquestração de contentores envia um evento SIGTERM, Run é desbloqueado e ocorrem as seguintes ações:

1. ApplicationStopping os tokens são acionados, o que permite à aplicação executar lógica antes do início do processo de desligamento.

2. O Kestrel servidor é desligado, o que desativa novas ligações. O servidor aguarda que as solicitações nas ligações existentes sejam concluídas durante o tempo que o tempo limite de encerramento permitir. O servidor envia o cabeçalho de fechamento de conexão para solicitações adicionais em conexões existentes.

3. O anfitrião encerra os serviços registados hospedados. A menos que a aplicação opte por suspender serviços alojados em simultâneo (.NET 8 ou posterior), os serviços alojados param sequencialmente na ordem inversa dos seus registos de contentores DI. Para mais informações, consulte Tarefas em segundo plano com serviços alojados no ASP.NET Core.

4. ApplicationStopped Os gestores de eventos são ativados, o que permite à aplicação executar lógica depois de a aplicação ter sido desligada.

5. A execução na consola termina corretamente com um código de saída de 0.

A classe Startup configura serviços e o pipeline de solicitação do aplicativo.

A Startup classe

As aplicações ASP.NET Core usam uma classe de arranque, que é nomeada Startup por convenção. A classe Startup:

• Opcionalmente, inclui um método ConfigureServices para configurar os serviços de do aplicativo. Um serviço é um componente reutilizável que fornece funcionalidade de aplicativo. Os serviços são registados no ConfigureServices e consumidos em todo o aplicativo através de .
• Inclui um método Configure para criar o pipeline de processamento de solicitações do aplicativo.

ConfigureServices e Configure são chamados pelo tempo de execução do ASP.NET Core quando o aplicativo é iniciado:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        ...
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        ...
    }
}

A classe Startup é especificada quando o host do aplicativo é criado. A Startup classe é tipicamente especificada apelando WebHostBuilderExtensions.UseStartup ao construtor anfitrião:

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>();
            });
}

O host fornece serviços que estão disponíveis para o construtor de classe Startup. A aplicação adiciona serviços adicionais via ConfigureServices. Os serviços de host e aplicativo estão disponíveis em Configure e em todo o aplicativo.

Somente os seguintes tipos de serviço podem ser injetados no construtor Startup ao usar o Generic Host (IHostBuilder):

• IWebHostEnvironment
• IHostEnvironment
• IConfiguration

public class Startup
{
    private readonly IWebHostEnvironment _env;

    public Startup(IConfiguration configuration, IWebHostEnvironment env)
    {
        Configuration = configuration;
        _env = env;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        if (_env.IsDevelopment())
        {
        }
        else
        {
        }
    }
}

A maioria dos serviços não está disponível até que o Configure método seja chamado.

Várias Startup classes

Quando o aplicativo define classes Startup separadas para ambientes diferentes (por exemplo, StartupDevelopment), a classe Startup apropriada é selecionada em tempo de execução. A classe cujo sufixo de nome corresponde ao ambiente atual é priorizada. Se a aplicação for executada no Development ambiente e incluir tanto uma Startup classe como uma StartupDevelopment classe, a StartupDevelopment classe é utilizada. Para obter mais informações, consulte Usar vários ambientes.

O método ConfigureServices

O método opcional ConfigureServices é:

• Chamado pelo host antes do método Configure para configurar os serviços do aplicativo.
• As opções de configuração são definidas por convenção.

O host pode configurar alguns serviços antes que Startup métodos sejam chamados. Para obter mais informações, consulte ASP.NET Visão geral dos fundamentos básicos.

Para funcionalidades que exigem uma configuração substancial, existem Add{Service} métodos de extensão em IServiceCollection, tais como:

• AddDbContext
• AddDefaultIdentity
• AddEntityFrameworkStores
• AddRazorPages

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

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));
        services.AddDefaultIdentity<IdentityUser>(
            options => options.SignIn.RequireConfirmedAccount = true)
            .AddEntityFrameworkStores<ApplicationDbContext>();

        services.AddRazorPages();
    }
}

Adicionar serviços ao contêiner de serviço os torna disponíveis no aplicativo e no método Configure. Os serviços são resolvidos por injeção de dependência através de ou a partir de ApplicationServices.

O método Configure

O método Configure é usado para especificar como o aplicativo responde a solicitações HTTP. O pipeline de solicitação é configurado adicionando middleware componentes a uma instância IApplicationBuilder. IApplicationBuilder está disponível para o método Configure, mas não está registrado no contêiner de serviço. A hospedagem cria um IApplicationBuilder e o passa diretamente para Configure.

Os modelos ASP.NET Core configuram o pipeline com suporte para:

• Página de exceção do desenvolvedor
• Manipulador de exceções
• Segurança de Transporte Estrita HTTP (HSTS)
• Redirecionamento HTTPS
• Arquivos estáticos
• ASP.NET Core MVC e Razor Páginas

O exemplo seguinte demonstra o middleware de uma aplicação Razor Pages típica:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

O exemplo anterior é para Razor Pages; a versão MVC é semelhante.

Cada método de extensão Use adiciona um ou mais componentes de middleware ao pipeline de solicitação. Por exemplo, UseStaticFiles configura o middleware para servir arquivos estáticos .

Cada componente de middleware no pipeline de solicitação é responsável por invocar o próximo componente no pipeline ou interromper a cadeia, se apropriado.

Serviços adicionais, como IWebHostEnvironment, ILoggerFactoryou qualquer coisa definida em ConfigureServices, podem ser especificados na assinatura do método Configure. Esses serviços são injetados se estiverem disponíveis.

Para mais informações sobre como usar IApplicationBuilder e a ordem do processamento do middleware, consulte middleware ASP.NET Core.

Configurar serviços sem uma Startup classe

Para configurar serviços e o pipeline de processamento de solicitações sem usar uma classe Startup, chame os métodos de conveniência ConfigureServices e Configure no host builder. Várias chamadas para ConfigureServices se somam umas às outras. Se existirem várias chamadas de método Configure, a última chamada Configure será usada.

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
            })
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.ConfigureServices(services =>
                {
                    ...
                })
                .Configure(app =>
                {
                    ...
                });
        });
}

A implementação do filtro de arranque está registada no Program ficheiro:

builder.Services.AddTransient<IStartupFilter, CustomResponseHeaderFilter>();

A implementação do filtro de arranque está registada em Startup.ConfigureServices:

services.AddTransient<IStartupFilter, CustomResponseHeaderFilter>();

A classe Startup (métodos ConfigureServices e Configure)

Embora seja suportado em aplicações ASP.NET Core que visam .NET 6 ou versões posteriores, não é recomendado usar uma Startup classe. Para mais informações, veja Migrar de ASP.NET Core em .NET 5 para .NET 6.

Para obter informações sobre como utilizar os métodos ConfigureServices e Configure com o modelo de alojamento mínimo, consulte o seguinte:

• Usa uma Startup classe com o modelo de alojamento mínimo
• A Startup classe (versão .NET 5 deste artigo)

Mede o desempenho de arranque

O alojamento EventSource ASP.NET Core emite o ServerReady evento, que representa o ponto em que o servidor está pronto para responder a pedidos e pode ser usado para medir o tempo de arranque. Para obter mais informações, consulte Logging no .NET e no ASP.NET Core.