ASP.NET Core Webový hostitel

ASP.NET Core aplikace nakonfigurují a spouštějí hostitele. Hostitel zodpovídá za spuštění aplikace a správu životního cyklu. Minimálně hostitel nakonfiguruje server a kanál zpracování požadavků. Hostitel může také nastavit protokolování, vkládání závislostí a konfiguraci.

Tento článek se zabývá webovým hostitelem, který zůstává dostupný jenom pro zpětnou kompatibilitu. šablony ASP.NET Core vytvoří obecného hostitele .net, který se doporučuje pro všechny typy aplikací.

Tento článek se zabývá webovým hostitelem, který je určený pro hostování webových aplikací. Pro jiné druhy aplikací použijte obecného hostitele.

Nastavení hostitele

Vytvořte hostitele pomocí instance IWebHostBuilder. To se obvykle provádí v vstupním bodě aplikace, Main metodě.

V šablonách projektů Main se nachází v programu program. cs. Typická aplikace volá CreateDefaultBuilder , aby zahájila 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ě s názvem CreateWebHostBuilder , která ho odděluje od kódu v Main volání Run objektu Builder. Toto oddělení se vyžaduje při použití Entity Framework Corech nástrojů. Nástroje očekávají CreateWebHostBuilder , že vyvolají metodu, kterou můžou zavolat v době návrhu, aby se nakonfiguroval hostitel bez spuštění aplikace. Alternativou je implementace IDesignTimeDbContextFactory . Další informace najdete v tématu vytváření DbContext při návrhu.

CreateDefaultBuilder provede následující úlohy:

Konfiguraci definovanou pomocí CreateDefaultBuilder lze přepsat a rozšířit ConfigureAppConfiguration, ConfigureLogginga dalšími metodami a metodami rozšíření IWebHostBuilder. Následuje několik příkladů:

  • ConfigureAppConfiguration se používá k určení dalších IConfiguration aplikací. Následující ConfigureAppConfiguration volání přidá delegáta pro zahrnutí konfigurace aplikace do souboru appsettings.xml . ConfigureAppConfiguration může být volána několikrá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 pro konfiguraci minimální úrovně protokolování (SetMinimumLevel) na LogLevel. Warning. Toto nastavení přepíše nastavení v appsettings.Development.jszapnuto ( LogLevel.Debug ) a appsettings.Production.jsna ( LogLevel.Error ) nakonfigurované pomocí CreateDefaultBuilder . ConfigureLogging může být volána několikrát.

    WebHost.CreateDefaultBuilder(args)
        .ConfigureLogging(logging => 
        {
            logging.SetMinimumLevel(LogLevel.Warning);
        })
        ...
    
  • Následující volání ConfigureKestrel přepíše výchozí omezení. MaxRequestBodySize 30 000 000 bajtů vytvořených při Kestrel konfiguraci CreateDefaultBuilder :

    WebHost.CreateDefaultBuilder(args)
        .ConfigureKestrel((context, options) =>
        {
            options.Limits.MaxRequestBodySize = 20000000;
        });
    
  • Následující volání pro použití Kestrel přepisuje výchozí limity. MaxRequestBodySize bajtů navázaných na 30 000 000 bajtů, které Kestrel byly nakonfigurovány pomocí CreateDefaultBuilder :

    WebHost.CreateDefaultBuilder(args)
        .UseKestrel(options =>
        {
            options.Limits.MaxRequestBodySize = 20000000;
        });
    

Kořen obsahu určuje, kde hostitel vyhledává soubory obsahu, například soubory zobrazení MVC. Při spuštění aplikace z kořenové složky projektu se jako kořen obsahu použije kořenová složka projektu. toto je výchozí nastavení používané v Visual Studio a dotnet new templates.

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ým přístupem s ASP.NET Core 2. x.

Při nastavování hostitele je možné zadat metody Konfigurace a ConfigureServices . Pokud Startup je třída zadána, musí definovat Configure metodu. Další informace naleznete v tématu Spuštění aplikace v ASP.NET Core. Několik volání, která se mají ConfigureServices navzájem připojit. Vícenásobné volání Configure nebo UseStartup v WebHostBuilder nastavení nahradit předchozí.

Hodnoty konfigurace hostitele

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

  • Konfigurace tvůrce hostitele, což zahrnuje proměnné prostředí ve formátu ASPNETCORE_{configurationKey} . Například, ASPNETCORE_ENVIRONMENT.
  • Rozšíření jako UseContentRoot a UseConfiguration (viz oddíl pro přepsání konfigurace ).
  • UseSetting a přidružený klíč. Při nastavení hodnoty s hodnotou UseSetting je hodnota nastavena jako řetězec bez ohledu na typ.

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

Klíč aplikace (název)

IWebHostEnvironment.ApplicationNameVlastnost je automaticky nastavena při volání UseStartup nebo Configure během vytváření hostitele. Hodnota je nastavená na název sestavení, které obsahuje vstupní bod aplikace. Chcete-li nastavit hodnotu explicitně, použijte WebHostDefaults. ApplicationKey:

Vlastnost IHostingEnvironment. ApplicationName je automaticky nastavena při volání UseStartup nebo Configure během vytváření hostitele. Hodnota je nastavená na název sestavení, které obsahuje vstupní bod aplikace. Chcete-li nastavit hodnotu explicitně, použijte WebHostDefaults. ApplicationKey:

Klíč: ApplicationName
Typ: řetězec
Výchozí: název sestavení, které obsahuje vstupní bod aplikace.
Nastavit pomocí: UseSetting
Proměnná prostředí: ASPNETCORE_APPLICATIONNAME

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

Zachytit chyby při spuštění

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

Klíč: captureStartupErrors
Typ: bool ( true nebo 1 )
Výchozí: ve výchozím nastavení false platí, že pokud je aplikace SPUŠTĚNÁ Kestrel za službou IIS, kde je výchozí hodnota true .
Nastavit pomocí: CaptureStartupErrors
Proměnná prostředí: ASPNETCORE_CAPTURESTARTUPERRORS

falseV důsledku dojde k chybám při spuštění hostitele. Když true hostitel zachytí výjimky během spouštění a pokusí se o spuštění serveru.

WebHost.CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)

Kořen obsahu

toto nastavení určuje, kde ASP.NET Core začne vyhledávat soubory obsahu.

Klíč: contentRoot
Typ: řetězec
Výchozí: výchozí nastavení složky, kde se nachází sestavení aplikace.
Nastavit pomocí: UseContentRoot
Proměnná prostředí: ASPNETCORE_CONTENTROOT

Kořen obsahu se používá také jako základní cesta pro kořenový adresář webu. Pokud kořenová cesta obsahu neexistuje, hostitele se nepodaří spustit.

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

Další informace naleznete v tématu:

Podrobné chyby

Určuje, zda mají být zachyceny podrobné chyby.

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

Když je tato možnost povolená (nebo když je prostředí nastavené na Development ), aplikace zachycuje podrobné výjimky.

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

Prostředí

Nastaví prostředí aplikace.

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

Prostředí lze nastavit na libovolnou hodnotu. Hodnoty definované rozhraním zahrnují Development , Staging a Production . U hodnot se nerozlišují malá a velká písmena. Ve výchozím nastavení je prostředí načteno z ASPNETCORE_ENVIRONMENT proměnné prostředí. při použití Visual Studiolze proměnné prostředí nastavit v souboru launchSettings.json . Další informace naleznete v tématu Používání více prostředí v ASP.NET Core.

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

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

Nastaví hostování spouštěcích sestavení aplikace.

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

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

I když je hodnota konfigurace výchozím prázdným řetězcem, hostující spouštěcí sestavení vždy zahrnuje sestavení aplikace. Po zadání hostování spouštěcích sestavení jsou přidána 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")

Port HTTPS

Nastavte port přesměrování HTTPS. Používá se při vynucování https.

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

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

Středníkem oddělený řetězec hostujících 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 hostování adres URL

Určuje, zda má hostitel naslouchat adresám URL nakonfigurovaným pomocí a WebHostBuilder místo nakonfigurovaných s IServer implementací.

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

WebHost.CreateDefaultBuilder(args)
    .PreferHostingUrls(false)

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

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

Klíč: preventHostingStartup
Typ: bool ( true nebo 1 )
Výchozí: 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 adresy hostitelů s porty a protokoly, na kterých má Server naslouchat požadavky.

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

Nastavte na středníkem oddělený (;) Seznam předpon adres URL, na které má server odpovědět Například, http://localhost:123. Pomocí příkazu " * " určete, že server má naslouchat žádostem na jakékoli 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á své vlastní rozhraní API pro konfiguraci koncového bodu. Další informace naleznete v tématu Konfigurace koncových bodů pro ASP.NET Core Kestrel serveru.

Kestrel má své vlastní rozhraní API pro konfiguraci koncového bodu. Další informace naleznete v tématu Kestrelimplementace webového serveru v ASP.NET Core.

Časový limit vypnutí

Určuje dobu, po kterou se má čekat na vypnutí webového hostitele.

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

I když klíč přijímá int s UseSetting (například .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10") ), metoda rozšíření UseShutdownTimeout přebírá časový interval.

Po uplynutí časového limitu hostování:

Pokud časový limit vyprší před zastavením všech hostovaných služeb, všechny zbývající aktivní služby se zastaví, jakmile se aplikace vypíná. Služby se zastavují i v případě, že se nedokončily zpracování. Pokud služby vyžadují ukončení déle, zvyšte časový limit.

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

Spouštěcí sestavení

Určuje sestavení, ve kterém má být vyhledána Startup Třída.

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

Lze odkazovat na sestavení podle názvu ( string ) nebo typu ( TStartup ). Pokud UseStartup je voláno více metod, má poslední z nich přednost.

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

Webový kořenový adresář

Nastaví relativní cestu k statickým assetům aplikace.

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

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

Další informace naleznete v tématu:

Přepsat konfiguraci

Pro konfiguraci webového hostitele použijte konfiguraci . V následujícím příkladu je konfigurace hostitele volitelně určena v hostsettings.js souboru. Jakákoli konfigurace načtená z hostsettings.jsv souboru může být přepsána argumenty příkazového řádku. Vytvořená konfigurace (v config ) se používá ke konfiguraci hostitele pomocí UseConfiguration. IWebHostBuilderkonfigurace je přidána do konfigurace aplikace, ale tato konverzace není pravdivá, — ConfigureAppConfiguration nemá vliv na IWebHostBuilder konfiguraci.

Přepsání konfigurace, kterou poskytuje UseUrls , pomocí hostsettings.jspři prvním nastavení konfigurace argumentu příkazového řádku:

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.js:

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

Poznámka

UseConfiguration zkopíruje pouze klíče ze zadaného IConfiguration do konfigurace tvůrce hostitele. Nastavení reloadOnChange: true souborů JSON, ini a XML nastavení proto nemá žádný vliv.

Chcete-li určit spuštění hostitele na konkrétní adrese URL, lze požadovanou hodnotu předat z příkazového řádku při spuštění příkazu dotnet. Argument příkazového řádku Přepisuje urls hodnotu z hostsettings.jsv souboru a server naslouchá na portu 8080:

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

Správa hostitele

Spustit

RunMetoda spustí webovou aplikaci a zablokuje volající vlákno, dokud nebude hostitel vypnutý:

host.Run();

Zahájení

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

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

Pokud se do metody předává seznam adres URL Start , naslouchá na zadaných adresách 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 s použitím předem nakonfigurovaných výchozích hodnot CreateDefaultBuilder pomocí statické metody pro usnadnění. Tyto metody spustí server bez výstupu konzoly a s WaitForShutdown čekají na přerušení (CTRL-C/SIGINT nebo SIGTERM):

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

V prohlížeči vytvořte žádost, aby http://localhost:5000 obdržela odpověď "Hello World!". WaitForShutdown blokuje až do vystavení přerušení (CTRL-C/SIGINT nebo SIGTERM). Aplikace zobrazí Console.WriteLine zprávu a počká, až se stisknutí klávesy ukončí.

Spustit (adresa URL řetězce, aplikace v RequestDelegate)

Začněte s 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, že aplikace reaguje http://localhost:8080 .

Spustit (akce <IRouteBuilder> routeBuilder)

IRouteBuilderPro použití middlewaru 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();
}

Použijte následující požadavky prohlížeče s příkladem:

Žádost Odpověď
http://localhost:5000/hello/Martin Hello, Novák!
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, Kevin!
http://localhost:5000 Hello World!

WaitForShutdown blokuje až do vystavení přerušení (CTRL-C/SIGINT nebo SIGTERM). Aplikace zobrazí Console.WriteLine zprávu a počká, až se stisknutí klávesy 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, že aplikace reaguje na http://localhost:8080 .

StartWith (akce <IApplicationBuilder> aplikace)

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

V prohlížeči vytvořte žádost, aby http://localhost:5000 obdržela odpověď "Hello World!". WaitForShutdown blokuje až do vystavení přerušení (CTRL-C/SIGINT nebo SIGTERM). Aplikace zobrazí Console.WriteLine zprávu a počká, až se stisknutí klávesy ukončí.

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

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 akce <IApplicationBuilder> ), kromě toho, že aplikace reaguje http://localhost:8080 .

Rozhraní IWebHostEnvironment

IWebHostEnvironmentRozhraní poskytuje informace o prostředí hostování webu aplikace. Použijte Injektáže konstruktoru pro získání, aby IWebHostEnvironment bylo možné použít jeho vlastnosti a metody rozšíření:

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

Přístup založený na konvenci je možné použít ke konfiguraci aplikace při spuštění na základě prostředí. Alternativně můžete vložit IWebHostEnvironment do Startup konstruktoru konstruktor 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 metody rozšíření, IWebHostEnvironment nabídky IsStaging , IsProduction a IsEnvironment(string environmentName) metody. Další informace naleznete v tématu Používání více prostředí v ASP.NET Core.

IWebHostEnvironmentSlužbu je také možné vložit přímo do Configure metody 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;
}

IWebHostEnvironment dá se vložit do Invoke metody při vytváření vlastního middlewaru:

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

Rozhraní IHostingEnvironment

Rozhraní IHostingEnvironment poskytuje informace o prostředí hostování webu aplikace. Použijte Injektáže konstruktoru pro získání, aby IHostingEnvironment bylo možné použít jeho vlastnosti a metody rozšíření:

public class CustomFileReader
{
    private readonly IHostingEnvironment _env;

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

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

Přístup založený na konvenci je možné použít ke konfiguraci aplikace při spuštění na základě prostředí. Alternativně můžete vložit IHostingEnvironment do Startup konstruktoru konstruktor pro použití v ConfigureServices :

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

    public IHostingEnvironment HostingEnvironment { get; }

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

        var contentRootPath = HostingEnvironment.ContentRootPath;
    }
}

Poznámka

Kromě IsDevelopment metody rozšíření, IHostingEnvironment nabídky IsStaging , IsProduction a IsEnvironment(string environmentName) metody. Další informace naleznete v tématu Používání více prostředí v ASP.NET Core.

IHostingEnvironmentSlužbu je také možné vložit přímo do Configure metody nastavení kanálu zpracování:

public void Configure(IApplicationBuilder app, IHostingEnvironment 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;
}

IHostingEnvironment dá se vložit do Invoke metody při vytváření vlastního middlewaru:

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

    var contentRootPath = env.ContentRootPath;
}

Rozhraní IHostApplicationLifetime

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í Aktivované při…
ApplicationStarted Hostitel byl plně spuštěn.
ApplicationStopped Hostitel dokončuje řádné vypnutí. Všechny požadavky by se měly zpracovat. Bloky vypnutí, dokud se tato událost nedokončí.
ApplicationStopping Hostitel provádí bezproblémové vypnutí. Žádosti se pořád dají zpracovat. Bloky vypnutí, dokud se tato událost nedokončí.
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 požaduje ukončení aplikace. Následující třída používá StopApplication k bezproblémovému vypnutí aplikace při Shutdown volání metody třídy:

public class MyClass
{
    private readonly IHostApplicationLifetime _appLifetime;

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

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

Rozhraní IApplicationLifetime

IApplicationLifetime 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í Aktivované při…
ApplicationStarted Hostitel byl plně spuštěn.
ApplicationStopped Hostitel dokončuje řádné vypnutí. Všechny požadavky by se měly zpracovat. Bloky vypnutí, dokud se tato událost nedokončí.
ApplicationStopping Hostitel provádí bezproblémové vypnutí. Žádosti se pořád dají zpracovat. Bloky vypnutí, dokud se tato událost nedokončí.
public class Startup
{
    public void Configure(IApplicationBuilder app, IApplicationLifetime 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 žádá o ukončení aplikace. Následující třída používá StopApplication k bezproblémovému vypnutí aplikace při Shutdown volání metody třídy:

public class MyClass
{
    private readonly IApplicationLifetime _appLifetime;

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

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

Ověřování oboru

CreateDefaultBuilder nastaví ServiceProviderOptions. ValidateScopes na, true Pokud je prostředí aplikace vyvíjené.

Když ValidateScopes je nastavená na true , výchozí poskytovatel služby provede kontrolu, aby ověřil, že:

  • Oborové služby nejsou přímo nebo nepřímo vyřešeny od poskytovatele kořenové služby.
  • Oborové služby nejsou přímo nebo nepřímo vložené do singleton.

Poskytovatel kořenové služby se vytvoří, když se zavolá BuildServiceProvider . Doba života poskytovatele kořenové služby odpovídá době životnosti aplikace nebo serveru, když se poskytovatel spustí s aplikací a je uvolněný při ukončení aplikace.

Oborové služby jsou uvolněny kontejnerem, který je vytvořil. Pokud je v kořenovém kontejneru vytvořena vymezená služba, doba života služby je efektivně povýšena na typ singleton, protože je uvolněna pouze kořenovým kontejnerem při vypnutí aplikace nebo serveru. Při ověřování oborů služeb se tyto situace zachytí BuildServiceProvider .

Pokud chcete vždy ověřit obory, včetně v produkčním prostředí, nakonfigurujte ServiceProviderOptions pomocí UseDefaultServiceProvider na tvůrci hostitele:

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

Další materiály