Host Web ASP.NET Core

ASP.NET aplicativos principais configuram e iniciam um host. O host é responsável pela inicialização do aplicativo e gerenciamento do tempo de vida. No mínimo, o host configura um servidor e um pipeline de processamento de solicitações. O host também pode configurar o registro, a injeção de dependência e a configuração.

Este artigo aborda o hospedeiro da web, que permanece disponível apenas para compatibilidade retroativa. Os modelos ASP.NET Core criam um WebApplicationBuilder e WebApplication, que é recomendado para aplicativos Web. Para obter mais informações sobre WebApplicationBuilder e WebApplication, consulte Migrar do ASP.NET Core no .NET 5 para o .NET 6

Configurar um anfitrião

Crie um host usando uma instância do IWebHostBuilder. Isso geralmente é executado no ponto de entrada do aplicativo, no método Main em Program.cs. Um aplicativo típico chama CreateDefaultBuilder para começar a configurar um host:

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

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>();
}

O código que chama CreateDefaultBuilder está num método chamado CreateWebHostBuilder, o que o separa do código em Main que chama Run no objeto builder. Essa separação é necessária se você usar as ferramentas principais do Entity Framework. As ferramentas esperam encontrar um CreateWebHostBuilder método que possam chamar em tempo de concepção para configurar o servidor sem executar a aplicação. Uma alternativa é implementar IDesignTimeDbContextFactory. Para obter mais informações, consulte Criação de DbContext em tempo de design.

CreateDefaultBuilder executa as seguintes tarefas:

• Configura Kestrel o servidor como o servidor Web usando os provedores de configuração de hospedagem do aplicativo. Para obter as opções padrão do servidor Kestrel, consulte Configurar opções para o servidor Web ASP.NET Core Kestrel.
• Define a raiz de conteúdo para o caminho retornado por Directory.GetCurrentDirectory.
• Carrega a configuração do host de:
  • Variáveis de ambiente prefixadas com ASPNETCORE_ (por exemplo, ASPNETCORE_ENVIRONMENT).
  • Argumentos de linha de comando.
• Carrega a configuração da aplicação na seguinte ordem:
  • appsettings.json.
  • appsettings.{Environment}.json.
  • Segredos de usuário quando o aplicativo é executado no Development ambiente usando o assembly de entrada.
  • Variáveis de ambiente.
  • Argumentos de linha de comando.
• Configura o registo para saída de consola e depuração. O registo inclui regras de filtragem de log especificadas na seção de configuração de log de um ficheiro appsettings.json ou appsettings.{Environment}.json.
• Ao executar atrás do IIS com o ASP.NET Módulo Principal, CreateDefaultBuilder habilita a Integração do IIS, que configura o endereço base e a porta do aplicativo. A Integração do IIS também configura o aplicativo para capturar erros de inicialização. Para ver as opções padrão do IIS, consulte Hospedar ASP.NET Core no Windows com o IIS.
• Define ServiceProviderOptions.ValidateScopes como true se o ambiente da aplicação for o de Desenvolvimento. Para obter mais informações, consulte Validação de Escopo.

A configuração definida por CreateDefaultBuilder pode ser substituída e aumentada por ConfigureAppConfiguration, ConfigureLogging, e outros métodos e métodos de extensão de IWebHostBuilder. Seguem-se alguns exemplos:

• ConfigureAppConfiguration é usado para especificar IConfiguration adicionais para a aplicação. A seguinte chamada ConfigureAppConfiguration adiciona um delegado para incluir configuração de aplicativo no ficheiro appsettings.xml. ConfigureAppConfiguration pode ser chamado várias vezes. Observe que essa configuração não se aplica ao host (por exemplo, URLs ou ambiente do servidor). Consulte a seção Valores de configuração do host .

  WebHost.CreateDefaultBuilder(args)
      .ConfigureAppConfiguration((hostingContext, config) =>
      {
          config.AddXmlFile("appsettings.xml", optional: true, reloadOnChange: true);
      })
      ...
  

• A chamada a seguir ConfigureLogging adiciona um delegado para configurar o nível mínimo de log (SetMinimumLevel) para LogLevel.Warning. Essa configuração substitui as configurações em appsettings.Development.json (LogLevel.Debug) e appsettings.Production.json (LogLevel.Error) definidas por CreateDefaultBuilder. ConfigureLogging pode ser chamado várias vezes.

  WebHost.CreateDefaultBuilder(args)
      .ConfigureLogging(logging => 
      {
          logging.SetMinimumLevel(LogLevel.Warning);
      })
      ...
  

• A chamada a seguir substitui o padrão ConfigureKestrelLimits.MaxRequestBodySize de 30.000.000 bytes estabelecido quando Kestrel foi configurado por CreateDefaultBuilder:

  WebHost.CreateDefaultBuilder(args)
      .ConfigureKestrel((context, options) =>
      {
          options.Limits.MaxRequestBodySize = 20000000;
      });
  

A raiz de conteúdo determina onde o host procura arquivos de conteúdo, como arquivos de exibição MVC. Quando o aplicativo é iniciado a partir da pasta raiz do projeto, a pasta raiz do projeto é usada como a raiz do conteúdo. Este é o padrão usado no Visual Studio e os novos modelos dotnet.

Para obter mais informações sobre a configuração do aplicativo, consulte Configuração no ASP.NET Core.

Observação

Como alternativa ao uso do método estático CreateDefaultBuilder, criar um host a partir de WebHostBuilder é uma abordagem suportada com o ASP.NET Core 2.x.

Ao configurar um host, os métodos Configure e ConfigureServices podem ser fornecidos. Se uma Startup classe for especificada, ela deverá definir um Configure método. Para obter mais informações, consulte arranque da aplicação no ASP.NET Core. Várias chamadas para ConfigureServices se somam umas às outras. As múltiplas chamadas para Configure ou UseStartup em WebHostBuilder substituem as configurações anteriores.

Valores de configuração do host

WebHostBuilder Baseia-se nas seguintes abordagens para definir os valores de configuração do host:

• Configuração do construtor de hosts, que inclui variáveis de ambiente com o formato ASPNETCORE_{configurationKey}. Por exemplo, ASPNETCORE_ENVIRONMENT.
• Extensões como UseContentRoot e UseConfiguration (consulte a seção Configuração de substituição).
• UseSetting e a chave associada. Ao definir um valor com UseSetting, o valor é definido como uma cadeia de caracteres, independentemente do tipo.

O host usa qualquer opção que defina um valor por último. Para obter mais informações, consulte Configuração de substituição na próxima seção.

Chave de Aplicação (Nome)

A propriedade IWebHostEnvironment.ApplicationName é definida automaticamente quando UseStartup ou Configure são chamados durante a construção do host. O valor é definido como o nome do assembly que contém o ponto de entrada do aplicativo. Para definir o valor explicitamente, use o WebHostDefaults.ApplicationKey:

Chave: nomeDaAplicação
Tipo: cadeia
Padrão: o nome do assembly que contém o ponto de entrada do aplicativo.
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_APPLICATIONNAME

WebHost.CreateDefaultBuilder(args)
    .UseSetting(WebHostDefaults.ApplicationKey, "CustomApplicationName")

Capturar erros de inicialização

Essa configuração controla a captura de erros de inicialização.

Chave: captureStartupErrors
Tipo: bool (true ou 1)
padrão: o padrão é false a menos que o aplicativo seja executado com Kestrel atrás do IIS, onde o padrão é true.
Definir usando: CaptureStartupErrors
Variável Ambiente: ASPNETCORE_CAPTURESTARTUPERRORS

Quando false, erros durante a inicialização resultam na saída do host. Quando true, o host captura exceções durante a inicialização e tenta iniciar o servidor.

WebHost.CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)

Raiz do conteúdo

Essa configuração determina onde o ASP.NET Core começa a procurar arquivos de conteúdo.

Chave: contentRoot
Tipo: cadeia
Padrão: o padrão é a pasta onde o assembly do aplicativo reside.
Definir usando: UseContentRoot
Variável Ambiente: ASPNETCORE_CONTENTROOT

A raiz do conteúdo também é usada como o caminho base para o diretório raiz do site. Se o caminho raiz do conteúdo não existir, o host falhará ao iniciar.

WebHost.CreateDefaultBuilder(args)
    .UseContentRoot("c:\\<content-root>")

Para obter mais informações, consulte:

• Fundamentos: Raiz de conteúdo
• Raiz da Web

Erros detalhados

Determina se erros detalhados devem ser capturados.

Chave: erros detalhados
Tipo: bool (true ou 1)
Padrão: falso
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_DETAILEDERRORS

Quando ativado (ou quando o Ambiente está definido como Development), o aplicativo captura exceções detalhadas.

WebHost.CreateDefaultBuilder(args)
    .UseSetting(WebHostDefaults.DetailedErrorsKey, "true")

Meio Ambiente

Define o ambiente do aplicativo.

Chave: ambiente
Tipo: cadeia
Padrão: Produção
Definir usando: UseEnvironment
Variável Ambiente: ASPNETCORE_ENVIRONMENT

O ambiente pode ser definido para qualquer valor. Os valores definidos pela estrutura incluem Development, Staginge Production. Os valores não diferenciam maiúsculas de minúsculas. Por padrão, o Ambiente é obtido a ASPNETCORE_ENVIRONMENT partir da variável de ambiente. Ao usar o Visual Studio, variáveis de launchSettings.json ambiente podem ser definidas no arquivo. Para obter mais informações, consulte ASP.NET Core runtime environments.

WebHost.CreateDefaultBuilder(args)
    .UseEnvironment(EnvironmentName.Development)

Hospedagem de assemblies de inicialização

Define os assemblies de inicialização de hospedagem do aplicativo.

Chave: hostingStartupAssemblies
Tipo: cadeia
Default: String vazia
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_HOSTINGSTARTUPASSEMBLIES

Uma cadeia de caracteres delimitada por ponto-e-vírgula contendo assemblies de inicialização a carregar no arranque.

Embora o valor de configuração seja predefinido para uma string vazia, os assemblies de inicialização de hospedagem incluem sempre o assembly da aplicação. Quando os assemblies de inicialização de hospedagem são fornecidos, eles são adicionados ao assembly do aplicativo para serem carregados quando o aplicativo configura os seus serviços comuns durante a inicialização.

WebHost.CreateDefaultBuilder(args)
    .UseSetting(WebHostDefaults.HostingStartupAssembliesKey, "assembly1;assembly2")

Porta HTTPS

Defina a porta HTTPS para redirecionar se você obtiver uma conexão não-HTTPS. Usado para impor HTTPS . Essa configuração não faz com que o servidor escute na porta especificada. Ou seja, é possível redirecionar acidentalmente solicitações para uma porta não utilizada.

Chave: https_port
Tipo: cadeia
Padrão: Um valor padrão não está definido.
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_HTTPS_PORT

WebHost.CreateDefaultBuilder(args)
    .UseSetting("https_port", "8080")

Portas HTTPS

Defina as portas para escutar conexões HTTPS.

Chave: https_ports Tipo: string
Padrão: Um valor padrão não está definido.
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_HTTPS_PORTS

WebHost.CreateDefaultBuilder(args)
    .UseSetting("https_ports", "8080")

Portas HTTP

Defina as portas para escutar conexões HTTP.

Chave: http_ports Tipo: string
Padrão: Um valor padrão não está definido.
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_HTTP_PORTS

WebHost.CreateDefaultBuilder(args)
    .UseSetting("http_ports", "8080")

Hospedagem de Inicialização Excluir Assemblies

Uma cadeia de caracteres delimitada por ponto e vírgula que especifica as assemblies de inicialização a excluir no arranque.

Chave: hostingStartupExcludeAssemblies
Tipo: cadeia
Default: String vazia
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIES

WebHost.CreateDefaultBuilder(args)
    .UseSetting(WebHostDefaults.HostingStartupExcludeAssembliesKey, "assembly1;assembly2")

Prefira URLs de hospedagem

Indica se o host deve escutar as URLs configuradas com o WebHostBuilder em vez daquelas configuradas com a IServer implementação.

Chave: preferirURLsDeHospedagem
Tipo: bool (true ou 1)
Padrão: falso
Definir usando: PreferHostingUrls
Variável Ambiente: ASPNETCORE_PREFERHOSTINGURLS

WebHost.CreateDefaultBuilder(args)
    .PreferHostingUrls(true)

Impedir arranque de serviços de hospedagem

Previna o carregamento automático de assemblies de arranque de hospedagem, incluindo aqueles configurados pelo assembly da aplicação. Para obter mais informações, consulte Usar assemblies de inicialização de hospedagem no ASP.NET Core.

Chave: preventHostingStartup
Tipo: bool (true ou 1)
Padrão: falso
Definir usando: UseSetting
Variável Ambiente: ASPNETCORE_PREVENTHOSTINGSTARTUP

WebHost.CreateDefaultBuilder(args)
    .UseSetting(WebHostDefaults.PreventHostingStartupKey, "true")

URLs do servidor

Indica os endereços IP ou endereços de host com portas e protocolos que o servidor deve escutar para solicitações.

Chave: urls
Tipo: cadeia
Padrão: http://localhost:5000
Definir usando: UseUrls
Variável Ambiente: ASPNETCORE_URLS

Defina como uma lista separada por ponto-e-vírgula (;) de prefixos de URL aos quais o servidor deve responder. Por exemplo, http://localhost:123. Use "*" para indicar que o servidor deve escutar solicitações em qualquer endereço IP ou nome de host usando a porta e o protocolo especificados (por exemplo, http://*:5000). O protocolo (http:// ou https://) deve ser incluído em cada URL. Os formatos suportados variam entre servidores.

WebHost.CreateDefaultBuilder(args)
    .UseUrls("http://*:5000;http://localhost:5001;https://hostname:5002")

Kestrel tem a sua própria API de configuração de endpoint. Para obter mais informações, consulte Configurar endpoints para o servidor Web ASP.NET Core Kestrel.

Tempo limite de desligamento

Especifica a quantidade de tempo que se deve aguardar até o Web Host ser encerrado.

Chave: tempoLimiteDeDesligamentoSegundos
Tipo: int
Padrão: 5
Definir usando: UseShutdownTimeout
Variável Ambiente: ASPNETCORE_SHUTDOWNTIMEOUTSECONDS

Embora a chave aceite um int com UseSetting (por exemplo, .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10")), o método de extensão UseShutdownTimeout requer um TimeSpan.

Durante o período de pausa, hospedagem:

• Os gatilhos IApplicationLifetime.ApplicationStopping.
• Tenta parar os serviços hospedados, registrando quaisquer erros para os serviços que não conseguem parar.

Se o período de tempo limite expirar antes de todos os serviços hospedados pararem, todos os serviços ativos restantes serão interrompidos quando o aplicativo for desligado. Os serviços param mesmo que não tenham terminado o processamento. Se os serviços exigirem tempo adicional para parar, aumente o tempo limite.

WebHost.CreateDefaultBuilder(args)
    .UseShutdownTimeout(TimeSpan.FromSeconds(10))

Evento de Startups

Determina o assembly no qual procurar pela classe Startup.

Chave: startupAssembly
Tipo: cadeia
padrão: a montagem do aplicativo
Definir usando: UseStartup
Variável Ambiente: ASPNETCORE_STARTUPASSEMBLY

A assemblagem por nome (string) ou tipo (TStartup) pode ser referenciada. Se vários métodos UseStartup forem chamados, o último terá precedência.

WebHost.CreateDefaultBuilder(args)
    .UseStartup("StartupAssemblyName")

WebHost.CreateDefaultBuilder(args)
    .UseStartup<TStartup>()

Diretório raiz da web

Define o caminho relativo para os ativos estáticos do aplicativo.

Chave: webroot
Tipo: cadeia
Default: O padrão é wwwroot. O caminho para {content root}/wwwroot deve existir. Se o caminho não existir, um provedor de arquivos no-op será usado.
Definir usando: UseWebRoot
Variável Ambiente: ASPNETCORE_WEBROOT

WebHost.CreateDefaultBuilder(args)
    .UseWebRoot("public")

Para obter mais informações, consulte:

• Fundamentos: Raiz da Web
• Raiz do conteúdo

Sobrescrever configuração

Use Configuração para configurar o Host da Web. No exemplo a seguir, a configuração do host é opcionalmente especificada em um hostsettings.json arquivo. Qualquer configuração carregada a partir do hostsettings.json arquivo pode ser substituída por argumentos de linha de comando. A configuração construída (em config) é usada para configurar o host com UseConfiguration. IWebHostBuilder A configuração é adicionada à configuração do aplicativo, mas o inverso não é verdadeiro —ConfigureAppConfiguration não afeta a IWebHostBuilder configuração.

Substituindo a configuração fornecida por UseUrls com a configuração hostsettings.json primeiro, e em segundo lugar, a configuração por argumento de linha de comando.

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

    public static IWebHostBuilder CreateWebHostBuilder(string[] args)
    {
        var config = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("hostsettings.json", optional: true)
            .AddCommandLine(args)
            .Build();

        return WebHost.CreateDefaultBuilder(args)
            .UseUrls("http://*:5000")
            .UseConfiguration(config)
            .Configure(app =>
            {
                app.Run(context => 
                    context.Response.WriteAsync("Hello, World!"));
            });
    }
}

hostsettings.json:

{
    urls: "http://*:5005"
}

Observação

UseConfiguration Copia apenas as chaves da configuração fornecida IConfiguration para a configuração do Host Builder. Portanto, a configuração reloadOnChange: true para arquivos de configurações JSON, INI e XML não tem efeito.

Para especificar a execução do host em uma URL específica, o valor desejado pode ser passado de um prompt de comando ao executar dotnet run. O argumento de linha de comando substitui o valor do urlshostsettings.json arquivo, e o servidor ouve na porta 8080:

dotnet run --urls "http://*:8080"

Gerir o anfitrião

Executar

O Run método inicia o aplicativo Web e bloqueia o thread de chamada até que o host seja desligado:

host.Run();

Início

Execute o host de maneira sem bloqueio, chamando seu Start método:

using (host)
{
    host.Start();
    Console.ReadLine();
}

Se uma lista de URLs for passada para o Start método, ela escutará as URLs especificadas:

var urls = new List<string>()
{
    "http://*:5000",
    "http://localhost:5001"
};

var host = new WebHostBuilder()
    .UseKestrel()
    .UseStartup<Startup>()
    .Start(urls.ToArray());

using (host)
{
    Console.ReadLine();
}

A aplicação pode inicializar e iniciar um novo host através dos padrões pré-configurados de CreateDefaultBuilder por meio de um método conveniente estático. Estes métodos iniciam o servidor sem saída de console e WaitForShutdown aguardam por uma interrupção (Ctrl-C/SIGINT ou SIGTERM):

Iniciar(aplicativo RequestDelegate)

Comece com um RequestDelegate:

using (var host = WebHost.Start(app => app.Response.WriteAsync("Hello, World!")))
{
    Console.WriteLine("Use Ctrl-C to shutdown the host...");
    host.WaitForShutdown();
}

Faça uma solicitação no navegador para http://localhost:5000 receber a resposta "Olá Mundo!" WaitForShutdown até que uma pausa (Ctrl-C/SIGINT ou SIGTERM) seja emitida. O aplicativo exibe a mensagem Console.WriteLine e aguarda que uma tecla seja pressionada para sair.

Iniciar(string url, aplicativo RequestDelegate)

Comece com um URL e RequestDelegate:

using (var host = WebHost.Start("http://localhost:8080", app => app.Response.WriteAsync("Hello, World!")))
{
    Console.WriteLine("Use Ctrl-C to shutdown the host...");
    host.WaitForShutdown();
}

Produz o mesmo resultado que Start(RequestDelegate app), exceto que o aplicativo responde em http://localhost:8080.

Start(Ação<IRouteBuilder> routeBuilder)

Use uma instância de IRouteBuilder (Microsoft.AspNetCore.Routing) para utilizar o middleware de roteamento:

using (var host = WebHost.Start(router => router
    .MapGet("hello/{name}", (req, res, data) => 
        res.WriteAsync($"Hello, {data.Values["name"]}!"))
    .MapGet("buenosdias/{name}", (req, res, data) => 
        res.WriteAsync($"Buenos dias, {data.Values["name"]}!"))
    .MapGet("throw/{message?}", (req, res, data) => 
        throw new Exception((string)data.Values["message"] ?? "Uh oh!"))
    .MapGet("{greeting}/{name}", (req, res, data) => 
        res.WriteAsync($"{data.Values["greeting"]}, {data.Values["name"]}!"))
    .MapGet("", (req, res, data) => res.WriteAsync("Hello, World!"))))
{
    Console.WriteLine("Use Ctrl-C to shutdown the host...");
    host.WaitForShutdown();
}

Use as seguintes solicitações do navegador com o exemplo:

Solicitação	Resposta
http://localhost:5000/hello/Martin	Olá, Martin!
http://localhost:5000/buenosdias/Catrina	Buenos días, Catrina!
http://localhost:5000/throw/ooops!	Lança uma exceção com a string "ooops!"
http://localhost:5000/throw	Lança uma exceção com a string "Uh oh!"
http://localhost:5000/Sante/Kevin	Sante, Kevin!
http://localhost:5000	Olá, mundo!

WaitForShutdown bloqueia até que uma interrupção (Ctrl-C/SIGINT ou SIGTERM) seja emitida. O aplicativo exibe a mensagem Console.WriteLine e aguarda que uma tecla seja pressionada para sair.

Start(string url, Action<IRouteBuilder> routeBuilder)

Use uma URL e uma instância de IRouteBuilder:

using (var host = WebHost.Start("http://localhost:8080", router => router
    .MapGet("hello/{name}", (req, res, data) => 
        res.WriteAsync($"Hello, {data.Values["name"]}!"))
    .MapGet("buenosdias/{name}", (req, res, data) => 
        res.WriteAsync($"Buenos dias, {data.Values["name"]}!"))
    .MapGet("throw/{message?}", (req, res, data) => 
        throw new Exception((string)data.Values["message"] ?? "Uh oh!"))
    .MapGet("{greeting}/{name}", (req, res, data) => 
        res.WriteAsync($"{data.Values["greeting"]}, {data.Values["name"]}!"))
    .MapGet("", (req, res, data) => res.WriteAsync("Hello, World!"))))
{
    Console.WriteLine("Use Ctrl-C to shut down the host...");
    host.WaitForShutdown();
}

Produz o mesmo resultado que Start(Action<IRouteBuilder> routeBuilder), exceto que o aplicativo responde em http://localhost:8080.

StartWith(aplicativo<Action IApplicationBuilder> )

Forneça um delegado para configurar um IApplicationBuilder:

using (var host = WebHost.StartWith(app => 
    app.Use(next => 
    {
        return async context => 
        {
            await context.Response.WriteAsync("Hello World!");
        };
    })))
{
    Console.WriteLine("Use Ctrl-C to shut down the host...");
    host.WaitForShutdown();
}

Faça uma solicitação no navegador para http://localhost:5000 receber a resposta "Olá Mundo!" WaitForShutdown até que uma pausa (Ctrl-C/SIGINT ou SIGTERM) seja emitida. O aplicativo exibe a mensagem Console.WriteLine e aguarda que uma tecla seja pressionada para sair.

StartWith(url da cadeia de caracteres, aplicativo Action<IApplicationBuilder> )

Forneça uma URL e um delegado para configurar um IApplicationBuilder:

using (var host = WebHost.StartWith("http://localhost:8080", app => 
    app.Use(next => 
    {
        return async context => 
        {
            await context.Response.WriteAsync("Hello World!");
        };
    })))
{
    Console.WriteLine("Use Ctrl-C to shut down the host...");
    host.WaitForShutdown();
}

Produz o mesmo resultado que StartWith(Action<IApplicationBuilder> app), exceto que o aplicativo responde em http://localhost:8080.

Interface IWebHostEnvironment

A IWebHostEnvironment interface fornece informações sobre o ambiente de hospedagem web do aplicativo. Use a injeção do construtor para obter o IWebHostEnvironment e utilizar as suas propriedades e métodos de extensão:

public class CustomFileReader
{
    private readonly IWebHostEnvironment _env;

    public CustomFileReader(IWebHostEnvironment env)
    {
        _env = env;
    }

    public string ReadFile(string filePath)
    {
        var fileProvider = _env.WebRootFileProvider;
        // Process the file here
    }
}

Uma abordagem baseada em convenção pode ser usada para configurar o aplicativo na inicialização com base no ambiente. Em alternativa, injete o IWebHostEnvironment no construtor Startup para utilização em ConfigureServices:

public class Startup
{
    public Startup(IWebHostEnvironment env)
    {
        HostingEnvironment = env;
    }

    public IWebHostEnvironment HostingEnvironment { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        if (HostingEnvironment.IsDevelopment())
        {
            // Development configuration
        }
        else
        {
            // Staging/Production configuration
        }

        var contentRootPath = HostingEnvironment.ContentRootPath;
    }
}

Observação

Além do IsDevelopment método de extensão, IWebHostEnvironment oferece IsStaging, IsProduction, e IsEnvironment(string environmentName) métodos. Para obter mais informações, consulte ASP.NET Core runtime environments.

O IWebHostEnvironment serviço também pode ser injetado diretamente no Configure método para configurar o pipeline de processamento.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        // In Development, use the Developer Exception Page
        app.UseDeveloperExceptionPage();
    }
    else
    {
        // In Staging/Production, route exceptions to /error
        app.UseExceptionHandler("/error");
    }

    var contentRootPath = env.ContentRootPath;
}

IWebHostEnvironment pode ser injetado no método Invoke ao criar middleware personalizado:

public async Task Invoke(HttpContext context, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        // Configure middleware for Development
    }
    else
    {
        // Configure middleware for Staging/Production
    }

    var contentRootPath = env.ContentRootPath;
}

Interface IHostApplicationLifetime

IHostApplicationLifetime permite atividades pós-inicialização e desligamento. Três propriedades na interface são tokens de cancelamento usados para registar métodos Action que definem eventos de arranque e encerramento.

Token de cancelamento	Acionado quando...
ApplicationStarted	O anfitrião já começou completamente.
ApplicationStopped	O anfitrião está completando um desligamento elegante. Todos os pedidos devem ser processados. Blocos de desligamento até que este evento seja concluído.
ApplicationStopping	O anfitrião está realizando um encerramento suave. Os pedidos podem ainda estar a ser processados. Blocos de desligamento até que este evento seja concluído.

public class Startup
{
    public void Configure(IApplicationBuilder app, IHostApplicationLifetime appLifetime)
    {
        appLifetime.ApplicationStarted.Register(OnStarted);
        appLifetime.ApplicationStopping.Register(OnStopping);
        appLifetime.ApplicationStopped.Register(OnStopped);

        Console.CancelKeyPress += (sender, eventArgs) =>
        {
            appLifetime.StopApplication();
            // Don't terminate the process immediately, wait for the Main thread to exit gracefully.
            eventArgs.Cancel = true;
        };
    }

    private void OnStarted()
    {
        // Perform post-startup activities here
    }

    private void OnStopping()
    {
        // Perform on-stopping activities here
    }

    private void OnStopped()
    {
        // Perform post-stopped activities here
    }
}

StopApplication Solicita o encerramento do aplicativo. A classe a seguir usa StopApplication para desligar normalmente um aplicativo quando o método da Shutdown classe é chamado:

public class MyClass
{
    private readonly IHostApplicationLifetime _appLifetime;

    public MyClass(IHostApplicationLifetime appLifetime)
    {
        _appLifetime = appLifetime;
    }

    public void Shutdown()
    {
        _appLifetime.StopApplication();
    }
}

Validação do âmbito

CreateDefaultBuilder define ServiceProviderOptions.ValidateScopes para true se o ambiente da aplicação for Desenvolvimento.

Quando ValidateScopes definido como true, o provedor de serviços padrão executa verificações para verificar se:

• Serviços de escopo não são resolvidos, direta ou indiretamente, pelo provedor de serviços raiz.
• Os serviços com escopo não são direta ou indiretamente injetados em singletons.

O provedor de serviços raiz é criado quando BuildServiceProvider é chamado. O tempo de vida do provedor de serviços raiz corresponde ao tempo de vida do aplicativo/servidor quando o provedor começa com o aplicativo e é descartado quando o aplicativo é desligado.

Os serviços com escopo são descartados pelo contêiner que os criou. Se um serviço com escopo for criado no contêiner raiz, o tempo de vida do serviço será efetivamente promovido para singleton porque ele só será descartado pelo contêiner raiz quando o aplicativo/servidor for desligado. A validação de escopos de serviço deteta essas situações quando BuildServiceProvider é chamado.

Para sempre validar escopos, inclusive no ambiente de produção, configure o ServiceProviderOptions com UseDefaultServiceProvider no construtor de hosts:

WebHost.CreateDefaultBuilder(args)
    .UseDefaultServiceProvider((context, options) => {
        options.ValidateScopes = true;
    })

Recursos adicionais

• Alojar o ASP.NET Core no Windows com o IIS
• Hospedar o ASP.NET Core no Linux com o Nginx
• Host ASP.NET Core em um serviço do Windows