Webový hostitel ASP.NET Core

Aplikace ASP.NET Core konfigurují a spouští hostitele. Tento hostitel je zodpovědný za spouštění aplikací a správu doby života. Hostitel minimálně nakonfiguruje server a kanál zpracování požadavků. Hostitel může také nastavit protokolování, injektáž závislostí a konfiguraci.

Tento článek se zabývá webovým hostitelem, který zůstává k dispozici pouze pro zpětnou kompatibilitu. Šablony ASP.NET Core vytvoří WebApplicationBuilder šablonu, WebApplicationkterá se doporučuje pro webové aplikace. Další informace o WebApplicationBuilder a WebApplication viz Migrace z ASP.NET Core v .NET 5 na .NET 6

Nastavení hostitele

Vytvořte hostitele pomocí instance IWebHostBuilder. To se obvykle provádí v vstupním bodě aplikace, Main což je metoda v Program.cs. Typická volání CreateDefaultBuilder aplikací pro zahájení nastavování hostitele:

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

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

Kód, který volá CreateDefaultBuilder , je v metodě pojmenované CreateWebHostBuilder, která ji odděluje od kódu v Main této volání Run objektu tvůrce. Toto oddělení se vyžaduje, pokud používáte nástroje Entity Framework Core. Nástroje očekávají, že najdou metodu CreateWebHostBuilder , kterou můžou volat v době návrhu, aby nakonfigurovali hostitele bez spuštění aplikace. Alternativou je implementace IDesignTimeDbContextFactory. Další informace naleznete v tématu Vytvoření DbContext v době návrhu.

CreateDefaultBuilder provede následující úlohy:

• Nakonfiguruje Kestrel server jako webový server pomocí poskytovatelů konfigurace hostování aplikace. Kestrel Výchozí možnosti serveru najdete v tématu Kestrel ASP.NET Core.
• Nastaví kořen obsahu na cestu vrácenou .Directory.GetCurrentDirectory
• Načte konfiguraci hostitele z:
  • Proměnné prostředí s předponou ASPNETCORE_ (například ASPNETCORE_ENVIRONMENT).
  • Argumenty příkazového řádku
• Načte konfiguraci aplikace v následujícím pořadí:
  • appsettings.json.
  • appsettings.{Environment}.json.
  • Tajné kódy uživatelů při spuštění aplikace v Development prostředí pomocí vstupního sestavení.
  • Proměnné prostředí.
  • Argumenty příkazového řádku
• Konfiguruje protokolování pro výstup konzoly a ladění. Protokolování zahrnuje pravidla filtrování protokolů zadaná v části appsettings.json Konfigurace protokolování souboru nebo appsettings.{Environment}.json souboru.
• Při spouštění služby IIS pomocí základního ASP.NET povolí CreateDefaultBuilder služby IIS, která nakonfiguruje základní adresu a port aplikace. Integrace služby IIS také nakonfiguruje aplikaci tak, aby zachytila chyby při spuštění. Výchozí možnosti služby IIS najdete v tématu Hostitel ASP.NET Core ve Windows se službou IIS.
• Nastaví ServiceProviderOptions.ValidateScopes , true jestli je prostředí aplikace vývojové. Další informace najdete v tématu Ověření oboru.

Konfiguraci definovanou CreateDefaultBuilder lze přepsat a rozšířit pomocí ConfigureAppConfiguration, ConfigureLogginga dalších metod a rozšiřujících IWebHostBuildermetod . Následuje několik příkladů:

• ConfigureAppConfiguration slouží k zadání dalších IConfiguration pro aplikaci. Následující ConfigureAppConfiguration volání přidá delegáta, který do souboru zahrne konfiguraci appsettings.xml aplikace. ConfigureAppConfiguration může být volána vícekrát. Všimněte si, že tato konfigurace se nevztahuje na hostitele (například adresy URL serveru nebo prostředí). Viz část Hodnoty konfigurace hostitele.

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

• Následující ConfigureLogging volání přidá delegáta ke konfiguraci minimální úrovně protokolování (SetMinimumLevel) do LogLevel.Warning. Toto nastavení přepíše nastavení v appsettings.Development.json () a LogLevel.Debug (appsettings.Production.json) nakonfigurované uživatelem LogLevel.ErrorCreateDefaultBuilder. ConfigureLogging může být volána vícekrát.

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

• Následující volání ConfigureKestrel přepíše výchozí hodnoty Limits.MaxRequestBodySize 30 000 000 bajtů vytvořených při Kestrel konfiguraci CreateDefaultBuilder:

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

Kořenový adresář obsahu určuje, kde hostitel hledá soubory obsahu, například soubory zobrazení MVC. Když se aplikace spustí z kořenové složky projektu, kořenová složka projektu se použije jako kořen obsahu. Toto je výchozí nastavení používané v sadě Visual Studio a nové šablony dotnet.

Další informace o konfiguraci aplikace najdete v tématu Konfigurace v ASP.NET Core.

Poznámka:

Jako alternativu k použití statické CreateDefaultBuilder metody je vytvoření hostitele z WebHostBuilder podporovaného přístupu s ASP.NET Core 2.x.

Při nastavování hostitele Configure a ConfigureServices lze zadat metody. Pokud je zadána Startup třída, musí definovat metodu Configure . Další informace najdete v tématu Spuštění aplikace v ASP.NET Core. Více volání, která se mají ConfigureServices připojit k sobě. Více volání na Configure předchozí nastavení nebo UseStartup nahrazování WebHostBuilder předchozích nastavení.

Hodnoty konfigurace hostitele

WebHostBuilder spoléhá na následující přístupy k nastavení hodnot konfigurace hostitele:

• Konfigurace tvůrce hostitelů, která zahrnuje proměnné prostředí s formátem ASPNETCORE_{configurationKey}. Například ASPNETCORE_ENVIRONMENT.
• Rozšíření, jako UseContentRoot jsou a UseConfiguration (viz část Přepsání konfigurace ).
• UseSetting a přidružený klíč. Při nastavování hodnoty UseSettings hodnotou je hodnota nastavena jako řetězec bez ohledu na typ.

Hostitel používá tu, která možnost nastaví hodnotu jako poslední. Další informace najdete v tématu Přepsání konfigurace v další části.

Klíč aplikace (název)

Vlastnost IWebHostEnvironment.ApplicationName se automaticky nastaví, když UseStartup nebo Configure je volána během sestavování hostitelů. Hodnota je nastavena na název sestavení obsahujícího vstupní bod aplikace. Pokud chcete nastavit hodnotu explicitně, použijte:WebHostDefaults.ApplicationKey

Klíč: applicationName
Typ: řetězec
Výchozí: Název sestavení obsahující vstupní bod aplikace.
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_APPLICATIONNAME

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

Zachycení chyb při spuštění

Toto nastavení řídí zachycení chyb při spuštění.

Klíč: captureStartupErrors
Typ: bool (true nebo 1)
Výchozí hodnota: Výchozí hodnota platí, false pokud aplikace neběží se Kestrel službou IIS, kde výchozí hodnota je true.
Nastavit pomocí: CaptureStartupErrors
Proměnná prostředí: ASPNETCORE_CAPTURESTARTUPERRORS

Pokud falsedojde k chybám při spuštění, dojde k ukončení hostitele. Když truehostitel zaznamená výjimky při spuštění a pokusí se spustit server.

WebHost.CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)

Kořen obsahu

Toto nastavení určuje, kde ASP.NET Core začne hledat soubory obsahu.

Klíč: contentRoot
Typ: řetězec
Výchozí: Výchozí hodnota je složka, ve které se nachází sestavení aplikace.
Nastavit pomocí: UseContentRoot
Proměnná prostředí: ASPNETCORE_CONTENTROOT

Kořenový adresář obsahu se také používá jako základní cesta pro kořenový adresář webu. Pokud kořenová cesta k obsahu neexistuje, hostitel se nespustí.

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

Další informace naleznete v tématu:

• Základy: Kořen obsahu
• Kořen webu

Podrobné chyby

Určuje, jestli se mají zaznamenat podrobné chyby.

Klíč: podrobné chyby
Typ: bool (true nebo 1)
Výchozí hodnota: false
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_DETAILEDERRORS

Když je povolené (nebo když je prostředí nastavené Development), aplikace zaznamená podrobné výjimky.

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

Prostředí

Nastaví prostředí aplikace.

Klíč: prostředí
Typ: řetězec
Výchozí: Produkční
Nastavit pomocí: UseEnvironment
Proměnná prostředí: ASPNETCORE_ENVIRONMENT

Prostředí lze nastavit na libovolnou hodnotu. Hodnoty definované architekturou zahrnují Development, Staginga Production. V hodnotách se nerozlišuje malá a velká písmena. Ve výchozím nastavení se prostředí načte z ASPNETCORE_ENVIRONMENT proměnné prostředí. Při použití sady Visual Studio mohou být v launchSettings.json souboru nastaveny proměnné prostředí. Další informace viz prostředí runtime ASP.NET Core.

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

Hostování spouštěcích sestavení

Nastaví hostující spouštěcí sestavení aplikace.

Klíč: hostingStartupAssemblies
Typ: řetězec
Výchozí: Prázdný řetězec
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_HOSTINGSTARTUPASSEMBLIES

Středník oddělený řetězec hostování spouštěcích sestavení, která se mají načíst při spuštění.

I když se hodnota konfigurace ve výchozím nastavení nastaví na prázdný řetězec, hostitelské spouštěcí sestavení vždy obsahují sestavení aplikace. Při hostování spouštěcích sestavení se přidají do sestavení aplikace pro načtení, když aplikace během spouštění sestaví své běžné služby.

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

HTTPS Port

Nastavte port HTTPS tak, aby se přesměrovává, pokud se zobrazí připojení jiného typu než HTTPS. Používá se při vynucování HTTPS. Toto nastavení nezpůsobí, že server naslouchá na zadaném portu. To znamená, že je možné omylem přesměrovat požadavky na nepoužívaný port.

Klíč: https_port
Typ: řetězec
Výchozí hodnota: Výchozí hodnota není nastavená.
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_HTTPS_PORT

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

Porty HTTPS

Nastavte porty tak, aby naslouchaly připojení HTTPS.

Klíč: typ https_ports: řetězec
Výchozí hodnota: Výchozí hodnota není nastavená.
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_HTTPS_PORTS

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

Porty HTTP

Nastavte porty tak, aby čekaly na připojení HTTP.

Klíč: http_ports Typ: řetězec
Výchozí hodnota: Výchozí hodnota není nastavená.
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_HTTP_PORTS

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

Hostování spouštěcích vyloučení sestavení

Středník oddělený řetězec hostování spouštěcích sestavení, která se mají vyloučit při spuštění.

Klíč: hostingStartupExcludeAssemblies
Typ: řetězec
Výchozí: Prázdný řetězec
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIES

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

Preferovat adresy URL pro hostování

Určuje, jestli má hostitel naslouchat adresám URL nakonfigurovaným WebHostBuilder místo těch, které jsou nakonfigurované s implementací IServer .

Klíč: preferHostingUrls
Typ: bool (true nebo 1)
Výchozí hodnota: false
Nastavit pomocí: PreferHostingUrls
Proměnná prostředí: ASPNETCORE_PREFERHOSTINGURLS

WebHost.CreateDefaultBuilder(args)
    .PreferHostingUrls(true)

Zabránit spuštění hostování

Zabraňuje automatickému načítání hostitelských spouštěcích sestavení, včetně hostování spouštěcích sestavení nakonfigurovaných sestavením aplikace. Další informace viz Použití hostujících spouštěcích sestavení v ASP.NET Core.

Klíč: preventHostingStartup
Typ: bool (true nebo 1)
Výchozí hodnota: false
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_PREVENTHOSTINGSTARTUP

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

Adresy URL serveru

Označuje IP adresy nebo hostitelské adresy s porty a protokoly, na kterých má server naslouchat žádostem.

Klíč: adresy URL
Typ: řetězec
Výchozí hodnota: http://localhost:5000
Nastavit pomocí: UseUrls
Proměnná prostředí: ASPNETCORE_URLS

Nastavte na středník oddělený (;) seznam předpon adres URL, na které má server reagovat. Například http://localhost:123. Pomocí *označte, že server by měl naslouchat žádostem na libovolné IP adrese nebo názvu hostitele pomocí zadaného portu a protokolu (například http://*:5000). Protokol (http:// nebo https://) musí být součástí každé adresy URL. Podporované formáty se mezi servery liší.

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

Kestrel má vlastní rozhraní API konfigurace koncového bodu. Další informace najdete v tématu Kestrel ASP.NET Core.

Vypršení časového limitu vypnutí

Určuje dobu čekání na vypnutí webového hostitele.

Klíč: shutdownTimeoutSeconds
Typ: int
Výchozí hodnota: 5
Nastavit pomocí: UseShutdownTimeout
Proměnná prostředí: ASPNETCORE_SHUTDOWNTIMEOUTSECONDS

Ačkoli klíč přijímá int s UseSetting (například .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10")), UseShutdownTimeout metoda rozšíření přebírá TimeSpan.

Během časového limitu hostování:

• Aktivační události IApplicationLifetime.ApplicationStopping.
• Pokusí se zastavit hostované služby a protokolovat případné chyby služeb, které se nepodaří zastavit.

Pokud vyprší časový limit před zastavením všech hostovaných služeb, všechny zbývající aktivní služby se zastaví, když se aplikace vypne. Služby se zastaví i v případě, že nedokončily zpracování. Pokud služby vyžadují k zastavení další čas, zvyšte časový limit.

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

Spouštěcí sestavení

Určuje sestavení, které má vyhledat Startup třídu.

Klíč: startupAssembly
Typ: řetězec
Výchozí: Sestavení aplikace
Nastavit pomocí: UseStartup
Proměnná prostředí: ASPNETCORE_STARTUPASSEMBLY

Sestavení podle názvu (string) nebo typu (TStartup) lze odkazovat. Pokud se volá více UseStartup metod, má přednost poslední metoda.

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

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

Kořen webu

Nastaví relativní cestu ke statickým prostředkům aplikace.

Klíč: webroot
Typ: řetězec
Výchozí hodnota: Výchozí hodnota je wwwroot. Cesta k adresáři {content root}/wwwroot musí existovat. Pokud cesta neexistuje, použije se zprostředkovatel souboru no-op.
Nastavit pomocí: UseWebRoot
Proměnná prostředí: ASPNETCORE_WEBROOT

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

Další informace naleznete v tématu:

• Základy: Kořenový adresář webu
• Kořen obsahu

Přepsání konfigurace

Ke konfiguraci webového hostitele použijte konfiguraci konfigurace . V následujícím příkladu je konfigurace hostitele volitelně zadána hostsettings.json v souboru. Všechny konfigurace načtené ze hostsettings.json souboru mohou být přepsány argumenty příkazového řádku. Předdefinovaná konfigurace (in config) slouží ke konfiguraci hostitele s UseConfiguration. IWebHostBuilder Konfigurace se přidá do konfigurace aplikace, ale naopak není pravdivá –ConfigureAppConfiguration nemá vliv na IWebHostBuilder konfiguraci.

Přepsání konfigurace poskytnuté UseUrls pomocí hostsettings.json konfigurace první konfigurace, konfigurace argumentu příkazového řádku sekunda:

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"
}

Poznámka:

UseConfiguration kopíruje pouze klíče z poskytnuté IConfiguration konfigurace tvůrce hostitelů. Nastavení reloadOnChange: true pro soubory nastavení JSON, INI a XML proto nemá žádný vliv.

Pokud chcete určit spuštění hostitele na konkrétní adrese URL, může být požadovaná hodnota předána z příkazového řádku při spuštění dotnet. Argument příkazového urls řádku přepíše hostsettings.json hodnotu ze souboru a server naslouchá na portu 8080:

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

Správa hostitele

Běžet

Metoda Run spustí webovou aplikaci a zablokuje volající vlákno, dokud se hostitel nevypne:

host.Run();

Spustit

Spusťte hostitele neblokujícím způsobem voláním jeho Start metody:

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

Pokud se metodě předá Start seznam adres URL, naslouchá zadaným adresám URL:

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

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

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

Aplikace může inicializovat a spustit nového hostitele pomocí předem nakonfigurovaných výchozích CreateDefaultBuilder hodnot pomocí metody statického pohodlí. Tyto metody spustí server bez výstupu konzoly a WaitForShutdown počká na přerušení (Ctrl-C/SIGINT nebo SIGTERM):

Start(Aplikace RequestDelegate)

Začněte s RequestDelegate:

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

Vytvořte v prohlížeči http://localhost:5000 žádost o přijetí odpovědi "Hello World!" WaitForShutdown , dokud se nevystaví přerušení (Ctrl-C/SIGINT nebo SIGTERM). Aplikace zobrazí Console.WriteLine zprávu a počká, až se klávesová zkratka ukončí.

Start(adresa URL řetězce, aplikace RequestDelegate)

Začněte adresou URL a 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();
}

Vytvoří stejný výsledek jako start(aplikace RequestDelegate), s výjimkou toho, že aplikace odpoví .http://localhost:8080

Start(Action<IRouteBuilder routeBuilder> )

K použití middlewaru IRouteBuilder směrování použijte instanci (Microsoft.AspNetCore.Routing):

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

V příkladu použijte následující požadavky prohlížeče:

Požádat	Odezva
http://localhost:5000/hello/Martin	Dobrý den, Martine!
http://localhost:5000/buenosdias/Catrina	Buenos dias, Catrina!
http://localhost:5000/throw/ooops!	Vyvolá výjimku s řetězcem "ooops!"
http://localhost:5000/throw	Vyvolá výjimku s řetězcem "Uh oh!"
http://localhost:5000/Sante/Kevin	Sante, Kevine!
http://localhost:5000	Ahoj světe!

WaitForShutdown blokuje, dokud se nevystaví konec (Ctrl-C/SIGINT nebo SIGTERM). Aplikace zobrazí Console.WriteLine zprávu a počká, až se klávesová zkratka ukončí.

Start(adresa URL řetězce, akce<IRouteBuilder routeBuilder> )

Použijte adresu URL a instanci 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();
}

Vytvoří stejný výsledek jako Start(Action<IRouteBuilder routeBuilder> ) s výjimkou aplikace reaguje na http://localhost:8080adrese .

StartWith(Aplikace<IApplicationBuilder> akce)

Zadejte delegáta pro konfiguraci 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();
}

Vytvořte v prohlížeči http://localhost:5000 žádost o přijetí odpovědi "Hello World!" WaitForShutdown , dokud se nevystaví přerušení (Ctrl-C/SIGINT nebo SIGTERM). Aplikace zobrazí Console.WriteLine zprávu a počká, až se klávesová zkratka ukončí.

StartWith(adresa URL řetězce,<aplikace IApplicationBuilder> )

Zadejte adresu URL a delegáta pro konfiguraci 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();
}

Vytvoří stejný výsledek jako StartWith(aplikace<IApplicationBuilder> ) s výjimkou aplikace, na které http://localhost:8080aplikace reaguje .

IWebHostEnvironment – rozhraní

Rozhraní IWebHostEnvironment poskytuje informace o webovém hostitelském prostředí aplikace. Pomocí injektáže konstruktoru IWebHostEnvironment získejte vlastnosti a rozšiřující metody:

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
    }
}

Konvenční přístup se dá použít ke konfiguraci aplikace při spuštění na základě prostředí. Alternativně vložte do IWebHostEnvironment konstruktoru Startup pro použití v 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;
    }
}

Poznámka:

Kromě IsDevelopment rozšiřující metody nabízí IWebHostEnvironmentIsStaging, IsProductiona IsEnvironment(string environmentName) metody. Další informace viz prostředí runtime ASP.NET Core.

IWebHostEnvironment Službu lze také vložit přímo do Configure metody pro nastavení kanálu zpracování:

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

IWebHostEnvironmentlze do metody vložit při vytváření vlastního Invoke

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

IHostApplicationLifetime – rozhraní

IHostApplicationLifetime umožňuje aktivity po spuštění a vypnutí. Tři vlastnosti rozhraní jsou tokeny zrušení používané k registraci Action metod, které definují události spuštění a vypnutí.

Token zrušení	Aktivováno při...
ApplicationStarted	Hostitel je plně spuštěný.
ApplicationStopped	Hostitel provádí řádné vypnutí. Všechny požadavky by se měly zpracovat. Vypnutí blokuje, dokud se tato událost neskoní.
ApplicationStopping	Hostitel provádí řádné vypnutí. Žádosti se můžou dál zpracovávat. Vypnutí blokuje, dokud se tato událost neskoní.

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 žádost o ukončení aplikace. Následující třída se používá StopApplication k řádnému vypnutí aplikace při zavolání metody třídy Shutdown :

public class MyClass
{
    private readonly IHostApplicationLifetime _appLifetime;

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

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

Ověření oboru

CreateDefaultBuilder nastaví ServiceProviderOptions.ValidateScopes , true jestli je prostředí aplikace vývojové.

Pokud ValidateScopes je nastavená hodnota true, výchozí poskytovatel služeb provádí kontroly, aby ověřil, že:

• Služby s vymezeným oborem se přímo ani nepřímo nepřekládá od poskytovatele kořenových služeb.
• Služby s vymezeným oborem nejsou přímo ani nepřímo vloženy do singletonů.

Po zavolání se vytvoří BuildServiceProvider poskytovatel kořenové služby. Životnost poskytovatele kořenových služeb odpovídá životnosti aplikace nebo serveru, když poskytovatel začne s aplikací a je uvolněn při vypnutí aplikace.

Omezené služby jsou uvolněny kontejnerem, který je vytvořil. Pokud se v kořenovém kontejneru vytvoří služba s vymezeným oborem, životnost služby se efektivně zvýší na singleton, protože je odstraněna pouze kořenovým kontejnerem při vypnutí aplikace nebo serveru. Ověřování rozsahů služby tyto situace zachytí, když BuildServiceProvider je volána.

Pokud chcete vždy ověřovat obory, včetně v produkčním prostředí, nakonfigurujte ServiceProviderOptionsUseDefaultServiceProvider v tvůrci hostitelů:

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

Další materiály

• Hostování ASP.NET Core ve Windows pomocí služby IIS
• Hostování ASP.NET Core v Linuxu s Nginx
• Hostování ASP.NET Core ve službě Windows