ASP.NET Core webkiszolgáló

ASP.NET Core-alkalmazások konfigurálnak és indítanak el egy gazdagépet. A kiszolgáló felelős az alkalmazás indításáért és élettartam-kezeléséért. A gazdagép minimálisan egy kiszolgálót és egy kérésfeldolgozási folyamatot konfigurálja. A házigazda beállíthatja a naplózást, az injektálást és a konfigurálást is.

Ez a cikk a webtárhely-szolgáltatót ismerteti, amely csak visszamenőleges kompatibilitási célokra érhető el. A ASP.NET Core-sablonok létrehoznak egy WebApplicationBuilder és WebApplication, a webalkalmazásokhoz ajánlott sablont. További információ: WebApplicationBuilderWebApplicationMigrálás ASP.NET Core-ból .NET 5-ből .NET 6-ra

Gazdagép beállítása

Gazdagép létrehozása a következő példány IWebHostBuilderhasználatával: . Ez általában az alkalmazás belépési pontjában, a Main metódusban Program.cstörténik. A tipikus alkalmazás felhívja CreateDefaultBuilder, hogy megkezdje a gazdagép beállítását.

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

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

Az a kód, amely a CreateDefaultBuilder hívását kezdeményezi, egy CreateWebHostBuilder nevű metódusban található, amely elkülöníti azt a Main kódtól, amely a Run hívását indítja az építő objektumon. Erre az elkülönítésre az Entity Framework Core-eszközök használata esetén van szükség. Az eszközök arra számítanak, hogy találnak egy CreateWebHostBuilder metódust, amelyet a tervezéskor meghívhatnak, hogy az alkalmazás futtatása nélkül konfigurálják a gazdagépet. Egy másik lehetőség az IDesignTimeDbContextFactory megvalósítása. További információért lásd: Tervezési időben létrehozott DbContext.

CreateDefaultBuilder a következő feladatokat hajtja végre:

• Webkiszolgálóként konfigurálja Kestrel a kiszolgálót az alkalmazás üzemeltetési konfigurációs szolgáltatóinak használatával. A Kestrel kiszolgáló alapértelmezett beállításaiért lásd A ASP.NET Core Kestrel webkiszolgálóbeállításainak konfigurálása című témakört.
• A(z) tartalomgyökérként állítja be a-et a Directory.GetCurrentDirectoryáltal visszaadott elérési útra.
• Betölti a gazdagép konfigurációját a következőből:
  • Környezeti változók előtaggal ASPNETCORE_ (például ASPNETCORE_ENVIRONMENT).
  • Parancssori argumentumok.
• Az alkalmazáskonfiguráció betöltése a következő sorrendben:
  • appsettings.json.
  • appsettings.{Environment}.json.
  • Felhasználói titkos kódok , amikor az alkalmazás a Development környezetben fut a belépési szerelvény használatával.
  • Környezeti változók.
  • Parancssori argumentumok.
• Konfigurálja a konzol naplózását és a hibakeresési kimenetet. A naplózás tartalmaz naplószűrési szabályokat, amelyeket a naplózási beállítások szakaszában adtak meg egy appsettings.json vagy appsettings.{Environment}.json fájlban.
• Ha az IIS mögött fut a ASP.NET core modullal, CreateDefaultBuilder lehetővé teszi az IIS-integrációt, amely konfigurálja az alkalmazás alapcímét és portját. Az IIS-integráció az alkalmazást az indítási hibák rögzítésére is konfigurálja. Az IIS alapértelmezett beállításaiért lásd: ASP.NET Core tárhely szolgáltatás Windows rendszeren IIS-sel.
• Beállítja ServiceProviderOptions.ValidateScopes értékét true-re, ha az alkalmazás környezete fejlesztési környezet. További információ: Hatókör érvényesítése.

Az CreateDefaultBuilder által definiált konfiguráció felülírható és kibővíthető a ConfigureAppConfiguration, ConfigureLogging és a IWebHostBuilder metódusok és kiterjesztési metódusai által. Néhány példa:

• ConfigureAppConfiguration további IConfiguration megadására szolgál az alkalmazás számára. Az alábbi ConfigureAppConfiguration hívás egy meghatalmazottat ad hozzá az alkalmazáskonfiguráció fájlba való appsettings.xml felvételéhez. ConfigureAppConfiguration többször is meghívható. Vegye figyelembe, hogy ez a konfiguráció nem vonatkozik a gazdagépre (mint például a kiszolgálói URL-címekre vagy a környezetre). Lásd a Gazdagép konfigurációs értékei szakaszt .

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

• Az alábbi ConfigureLogging hívás hozzáad egy meghatalmazottat a minimális naplózási szint (SetMinimumLevel) LogLevel.Warning konfigurálásához. Ez a beállítás felülírja a appsettings.Development.json (LogLevel.Debug) és appsettings.Production.json (LogLevel.Error) beállításait, amelyeket CreateDefaultBuilder konfigurált. ConfigureLogging többször is meghívható.

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

• A következő hívás ConfigureKestrel felülírja az alapértelmezett Limits.MaxRequestBodySize értéket, amely 30 000 000 bájt, és amelyet akkor állítottak be, amikor Kestrel által CreateDefaultBuilder konfigurálva lett.

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

A tartalomgyökér határozza meg, hogy a hoszt hol keresi a tartalomfájlokat, mint például az MVC-nézetfájlokat. Amikor az alkalmazás a projekt gyökérmappájából indul el, a rendszer a projekt gyökérmappáját használja tartalomgyökerként. Ez az alapértelmezett használat a Visual Studióban és a dotnet új sablonjaiban.

Az alkalmazáskonfigurációval kapcsolatos további információkért lásd: Konfiguráció a ASP.NET Core-ban.

Megjegyzés:

Alternatívaként a statikus CreateDefaultBuilder módszer helyett az ASP.NET Core 2.x WebHostBuilder közötti gazdagép létrehozása támogatott megközelítés.

Gazdagép beállításakor a Configure és ConfigureServices metódusok megadhatóak. Ha egy Startup osztály meg van adva, meg kell határoznia egy metódust Configure . További információért lásd: Alkalmazás indítása ASP.NET Core. Több hívás a ConfigureServices-ra egymáshoz kapcsolódik. Többszöri hívás a Configure vagy UseStartup funkciókra a WebHostBuilder elemnél felülírja a korábbi beállításokat.

Hoszt konfigurációs értékek

WebHostBuilder a következő módszerekre támaszkodik a gazdagép konfigurációs értékeinek beállításához:

• Host builder konfiguráció, amely a ASPNETCORE_{configurationKey} formátumú környezeti változókat tartalmazza. Például: ASPNETCORE_ENVIRONMENT.
• Bővítmények, például UseContentRoot és UseConfiguration (lásd a Konfiguráció felülbírálása szakaszt).
• UseSetting és a társított kulcs. Ha értéket UseSettingad meg, az érték sztringként van beállítva a típustól függetlenül.

A gazdagép azt az opciót használja, amelyik utoljára állít be egy értéket. További információ: Konfiguráció felülbírálása a következő részben.

Alkalmazáskulcs (név)

A IWebHostEnvironment.ApplicationName tulajdonság automatikusan be van állítva a gazdagép felépítése során, amikor a UseStartup vagy Configure meghívásra kerül. Az érték az alkalmazás belépési pontját tartalmazó szerelvény nevére van állítva. Az érték explicit beállításához használja a következőt WebHostDefaults.ApplicationKey:

Kulcs: alkalmazásNeve
típus: karakterlánc
Alapértelmezett: Az alkalmazás belépési pontját tartalmazó szerelvény neve.
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_APPLICATIONNAME

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

Indítási hibák rögzítése

Ez a beállítás szabályozza az indítási hibák rögzítését.

Kulcs: captureStartupErrors
Típus: bool (true vagy 1)
Alapértelmezett: Alapértelmezés szerint false, kivéve, ha az alkalmazás az IIS mögött Kestrel módban fut, ahol az alapértelmezett érték true.
Beállítva ezzel: CaptureStartupErrors
környezeti változó: ASPNETCORE_CAPTURESTARTUPERRORS

Ha false, az indítás során előforduló hibák a gazdagép kilépését okozzák. Ha true, a gazdagép rögzíti a kivételeket az indításkor, és megpróbálja elindítani a kiszolgálót.

WebHost.CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)

Tartalomgyökér

Ez a beállítás határozza meg, hogy ASP.NET Core hol kezd tartalomfájlokat keresni.

Kulcs: contentRoot
típus: karakterlánc
Alapértelmezett: Az alkalmazásszerelvényt tartalmazó mappa alapértelmezett értéke.
Beállítva ezzel: UseContentRoot
környezeti változó: ASPNETCORE_CONTENTROOT

A tartalomgyökeret is a webgyökér alap elérési útjaként használják. Ha a tartalom gyökérút nem létezik, a kiszolgáló nem indul el.

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

További információkért lásd:

• alapjai: Tartalom gyökere
• Webes gyökér

Részletes hibák

Meghatározza, hogy a részletes hibákat rögzíteni kell-e.

Kulcs: részletesHibák
Típus: bool (true vagy 1)
Alapértelmezett: hamis
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_DETAILEDERRORS

Ha engedélyezve van (vagy ha a Környezet beállításra van állítva Development), az alkalmazás rögzíti a részletes kivételeket.

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

Környezet

Beállítja az alkalmazás környezetét.

Kulcs: környezet
típus: karakterlánc
Alapértelmezett: Éles
Beállítva ezzel: UseEnvironment
környezeti változó: ASPNETCORE_ENVIRONMENT

A környezet bármilyen értékre beállítható. A keretrendszer által definiált értékek közé tartozik a Development, a Stagingés a Production. Az értékek nem érzékenyek a kis- és nagybetűkre. Alapértelmezés szerint a környezet beolvasása a ASPNETCORE_ENVIRONMENT környezeti változóból történik. A Visual Studio használatakor előfordulhat, hogy környezeti változók is be lesznek állítva a launchSettings.json fájlban. További információért lásd: Több környezet használata az ASP.NET Core keretrendszerben.

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

Indítási összejövetelek szervezése

Beállítja az alkalmazás hosztolási indító szerelvényeit.

Kulcs: hostingStartupAssemblies
típus: karakterlánc
Alapértelmezett: Üres karakterlánc
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_HOSTINGSTARTUPASSEMBLIES

Az indításkor betöltendő, pontosvesszővel elválasztott összeállítások karakterlánca.

Bár a konfigurációs érték alapértelmezett értéke egy üres sztring, az üzemeltetési indítási szerelvények mindig tartalmazzák az alkalmazás szerelvényét. Ha biztosítják az indítási szerelvényeket, azokat az alkalmazás szerelvényéhez adják hozzá, hogy betöltődhessenek, amikor az alkalmazás az indítás során létrehozza a közös szolgáltatásait.

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

HTTPS-port

Állítsa be a HTTPS-portot, amelyre átirányít, ha nem HTTPS-kapcsolatot észlel. A HTTPS-kényszerítésénél használt. Ez a beállítás nem okozza, hogy a kiszolgáló a megadott porton figyel. Ez azt is lehetővé teszi, hogy véletlenül átirányítsa a kéréseket egy nem használt portra.

Kulcs: https_port
típus: karakterlánc
Alapértelmezett: Nincs beállítva alapértelmezett érték.
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_HTTPS_PORT

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

HTTPS-portok

Állítsa be a portokat a HTTPS-kapcsolatok figyeléséhez.

Kulcs: https_ports Típus: string
Alapértelmezett: Nincs beállítva alapértelmezett érték.
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_HTTPS_PORTS

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

Hosztolási indítási folyamat kizárása szerelvényekből

Indításkor kizárandó, pontosvesszővel elválasztott, hosting indító szerelvények sztringje.

Kulcs: hostingStartupExcludeAssemblies kizáró assembly-k
típus: karakterlánc
Alapértelmezett: Üres karakterlánc
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIES

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

Előnyben részesített host URL-ek

Azt jelzi, hogy a gazdagépnek az WebHostBuilder-val konfigurált URL-címekre kell-e figyelnie, az IServer-val konfiguráltak helyett.

Kulcs: preferHostingUrls
Típus: bool (true vagy 1)
Alapértelmezett: hamis
Beállítva ezzel: PreferHostingUrls
környezeti változó: ASPNETCORE_PREFERHOSTINGURLS

WebHost.CreateDefaultBuilder(args)
    .PreferHostingUrls(true)

Hosting szolgáltatás indításának megakadályozása

Megakadályozza a hosztindító szerelvények automatikus betöltését, beleértve az alkalmazás szerelvénye által konfigurált hosztindító szerelvényeket is. További információért lásd: Hosztolási indító összetevők használata az ASP.NET Core-ban.

Kulcs: preventHostingStartup
Típus: bool (true vagy 1)
Alapértelmezett: hamis
Beállítva ezzel: UseSetting
környezeti változó: ASPNETCORE_PREVENTHOSTINGSTARTUP

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

Kiszolgálói URL-címek

Azokat az IP-címeket vagy gazdagépcímeket jelzi, amelyek portjain és protokolljain a kiszolgálónak figyelnie kell a kérések fogadásához.

Kulcs: URL-címek
típus: karakterlánc
Alapértelmezett: http://localhost:5000
Beállítva ezzel: UseUrls
környezeti változó: ASPNETCORE_URLS

Állítsa be pontosvesszővel elválasztottra (;) azon URL-előtagok listáját, amelyekre a kiszolgálónak válaszolnia kell. Például: http://localhost:123. A "*" használatával jelezheti, hogy a kiszolgálónak a megadott port és protokoll (például http://*:5000) használatával kell figyelnie a kéréseket bármely IP-címen vagy gazdagépnéven. A protokollt (http:// vagy https://) minden URL-címhez hozzá kell adni. A támogatott formátumok kiszolgálók között eltérőek lehetnek.

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

Kestrel saját végpontkonfigurációs API-val rendelkezik. További információ: Az ASP.NET Core Kestrel webkiszolgáló végpontjainak konfigurálása.

Leállítási időtúllépés

Azt az időtartamot adja meg, amíg a webgazda leáll.

Kulcs: leállítási időtúllépés másodpercekben
Típus: int
Alapértelmezett: 5
Beállítva ezzel: UseShutdownTimeout
környezeti változó: ASPNETCORE_SHUTDOWNTIMEOUTSECONDS

Bár a kulcs elfogad egy intet a UseSetting (például .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10") esetén), a UseShutdownTimeout kiterjesztési metódus egy TimeSpan-t alkalmaz.

Az időtúllépési időszak alatt a tárhelyszolgáltatás:

• Eseményindítók IApplicationLifetime.ApplicationStopping.
• Megkísérli leállítani az üzemeltetett szolgáltatásokat, és naplózza azon szolgáltatások hibáit, amelyek nem sikerül leállítani.

Ha az időtúllépési időszak az összes üzemeltetett szolgáltatás leállása előtt lejár, a fennmaradó aktív szolgáltatások leállnak az alkalmazás leállásakor. A szolgáltatások akkor is leállnak, ha még nem fejezték be a feldolgozást. Ha a szolgáltatások további időt igényelnek a leállásra, növelje az időkorlátot.

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

Szerelvény indítása

Meghatározza azt az összeszerelést, amely az Startup osztályt keresni fog.

Kulcs: startupAssembly
típus: karakterlánc
Alapértelmezett: Az alkalmazás összeállítása
Beállítva ezzel: UseStartup
környezeti változó: ASPNETCORE_STARTUPASSEMBLY

A szerelvény neve (string) vagy típusa (TStartup) alapján hivatkozhat. Ha több UseStartup metódust hív meg, az utolsó élvez elsőbbséget.

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

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

Webes gyökér

Beállítja az alkalmazás statikus eszközeinek relatív elérési útját.

Kulcs: webroot
típus: karakterlánc
Alapértelmezett: Az alapértelmezett wwwroot. A elérési útnak {content root}/wwwroot léteznie kell. Ha az elérési út nem létezik, a rendszer egy no-op fájlszolgáltatót használ.
Beállítva ezzel: UseWebRoot
környezeti változó: ASPNETCORE_WEBROOT

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

További információkért lásd:

• Alapismeretek: Webes gyökér
• Tartalomgyökér

Konfiguráció felülírása

A Configuration segítségével konfigurálhatja a webkiszolgálót. Az alábbi példában a gazdagép konfigurációja opcionálisan meg van adva egy hostsettings.json fájlban. A fájlból hostsettings.json betöltött konfigurációkat parancssori argumentumok felülírhatják. A beépített konfiguráció (in config) segítségével konfigurálhatja a gazdagépet a következővel UseConfiguration: . IWebHostBuilder hozzáadásra kerül az alkalmazás konfigurációjához, de fordítva nem igaz—ConfigureAppConfiguration nem befolyásolja a IWebHostBuilder konfigurációt.

Felülírjuk a `UseUrls` által biztosított konfigurációt az elsőként `hostsettings.json` konfigurációval, másodikként a parancssori argumentum konfigurációval.

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

Megjegyzés:

UseConfiguration csak a megadott IConfiguration kulcsokat másolja a gazdagépszerkesztő konfigurációjába. Ezért a JSON-, reloadOnChange: true INI- és XML-beállítások beállításainak nincs hatása.

Ahhoz, hogy meghatározza, melyik host futtasson egy adott URL-en, a kívánt érték átadható a parancssorból, amikor végrehajtja a dotnet run parancsot. A parancssori argumentum felülbírálja a urlshostsettings.json fájl értékét, a kiszolgáló pedig a 8080-as porton figyel:

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

A gazdagép kezelése

Fut

A Run metódus elindítja a webalkalmazást, és blokkolja a hívó szálat, amíg a gazda le nem áll.

host.Run();

Elkezd

Futtassa a gazdagépet nem blokkoló módon a Start metódus meghívásával.

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

Ha az URL-címek listáját átadja a Start metódusnak, a megadott URL-címeken figyeli a következőt:

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

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

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

Az alkalmazás inicializálhat és elindíthat egy új gazdagépet a statikus kényelmi CreateDefaultBuilder módszer előre konfigurált alapértelmezett beállításaival. Ezek a metódusok konzolkimenet nélkül indítják el a kiszolgálót, és WaitForShutdown várják a szünetet (Ctrl-C/SIGINT vagy SIGTERM):

Start(RequestDelegate alkalmazás)

Kezdje a következővel RequestDelegate:

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

Küldjön egy kérést a böngészőben a http://localhost:5000 címre, hogy megkapja a választ: "Hello World!" WaitForShutdown blokkot tart mindaddig, amíg meg nem szakítják egy szünettel (Ctrl-C/SIGINT vagy SIGTERM). Az alkalmazás megjeleníti az Console.WriteLine üzenetet, és megvárja, hogy egy billentyűt megnyomjanak a kilépéshez.

Start(karakterlánc url, RequestDelegate app)

Kezdje egy URL-címmel és RequestDelegatea következővel:

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

Ugyanazt az eredményt eredményez, mint a Start(RequestDelegate app), kivéve, hogy az app a http://localhost:8080-n válaszol.

Start(Action<IRouteBuilder> routeBuilder)

Használjon egy példányt IRouteBuilder (Microsoft.AspNetCore.Routing) az útválasztási köztes szoftver használatához:

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

Használja a következő böngészőkéréseket a példával:

Kérelem	Válasz
http://localhost:5000/hello/Martin	Üdv, Martin!
http://localhost:5000/buenosdias/Catrina	Buenos dias, Catrina!
http://localhost:5000/throw/ooops!	Dob egy kivételt a "ooops!" karakterlánccal
http://localhost:5000/throw	Kivételt jelez az "Uh oh!" sztringgel
http://localhost:5000/Sante/Kevin	Sante, Kevin!
http://localhost:5000	Helló világ!

WaitForShutdown blokkol, amíg egy megszakítás (Ctrl-C/SIGINT vagy SIGTERM) ki nem adódik. Az alkalmazás megjeleníti az Console.WriteLine üzenetet, és megvárja, hogy egy billentyűt megnyomjanak a kilépéshez.

Start(sztring URL-címe, Action<IRouteBuilder> routeBuilder)

Egy URL-cím és egy példány IRouteBuilder használata:

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

Ugyanazt az eredményt hozza létre, mint a Start(Action<IRouteBuilder> routeBuilder), kivéve, hogy az alkalmazás a következő helyen http://localhost:8080válaszol.

StartWith(Action<IApplicationBuilder> alkalmazás)

Hozzon létre egy delegáltat az IApplicationBuilder konfigurálásához.

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

Küldjön egy kérést a böngészőben a http://localhost:5000 címre, hogy megkapja a választ: "Hello World!" WaitForShutdown blokkot tart mindaddig, amíg meg nem szakítják egy szünettel (Ctrl-C/SIGINT vagy SIGTERM). Az alkalmazás megjeleníti az Console.WriteLine üzenetet, és megvárja, hogy egy billentyűt megnyomjanak a kilépéshez.

StartWith(sztring URL-címe, Action<IApplicationBuilder> alkalmazás)

Adjon meg egy URL-címet és egy meghatalmazottat a IApplicationBuilder konfigurálásához.

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

Ugyanazt az eredményt hozza létre, mint a StartWith(Action<IApplicationBuilder> alkalmazás), azzal a különbséggel, hogy az alkalmazás a http://localhost:8080-en válaszol.

IWebHostEnvironment felület

A IWebHostEnvironment felület információt nyújt az alkalmazás webes üzemeltetési környezetéről. Konstruktorinjektálás használatával szerezze be a IWebHostEnvironment, hogy használhassa annak tulajdonságait és kiterjesztési metódusait.

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

Konvencióalapú megközelítéssel konfigurálhatja az alkalmazást indításkor a környezet alapján. Másik lehetőségként, injektálja a IWebHostEnvironment-t a Startup konstruktorába, hogy a ConfigureServices-ben használja.

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

Megjegyzés:

A IsDevelopment kiterjesztési metódus mellett a(z) IWebHostEnvironment, IsStaging, IsProduction, és IsEnvironment(string environmentName) metódusokat is kínálja. További információért lásd: Több környezet használata az ASP.NET Core keretrendszerben.

A IWebHostEnvironment szolgáltatás közvetlenül is injektálható a Configure feldolgozási folyamat beállításának módszerébe:

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 injektálható a Invoke metódusba, amikor egyéni köztes szoftvert hoz létre:

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 interfész

IHostApplicationLifetime lehetővé teszi az indítás utáni és a leállítási tevékenységeket. Az interfész három tulajdonsága lemondási tokenek, amelyeket az Action indítási és leállítási eseményeket meghatározó metódusok regisztrálásához használnak.

Lemondási jogkivonat	Akkor aktiválódik, ha...
ApplicationStarted	A gazdagép teljesen beindult.
ApplicationStopped	A szerver szabatos leállítást végez. Minden kérést fel kell dolgozni. Leállítási blokkok, amíg az esemény befejeződik.
ApplicationStopping	A szerver szabályos leállítást végez. Előfordulhat, hogy a kérések feldolgozása még folyamatban van. Leállítási blokkok, amíg az esemény befejeződik.

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 kéri az alkalmazás leállítását. Az alábbi osztály az alkalmazás elegáns leállítására használja StopApplication az osztály metódusának meghívásakor Shutdown :

public class MyClass
{
    private readonly IHostApplicationLifetime _appLifetime;

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

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

Hatókör érvényesítése

A CreateDefaultBuilder beállítja a ServiceProviderOptions.ValidateScopes értékét true-re, ha az alkalmazás környezete Fejlesztési.

Ha ValidateScopes be van állítva true, az alapértelmezett szolgáltató ellenőrzéseket végez annak ellenőrzéséhez, hogy:

• A hatókörbe tartozó szolgáltatások nem közvetlenül vagy közvetve oldódnak fel a gyökérszolgáltatás-szolgáltatótól.
• A hatókörű szolgáltatások nem közvetlenül vagy közvetve injektálhatók singletonokba.

A gyökérszolgáltató akkor jön létre, amikor a BuildServiceProvider meg van hívva. A gyökérszolgáltatás élettartama az alkalmazás/kiszolgáló élettartamának felel meg, amikor a szolgáltató elindul az alkalmazással, és az alkalmazás leállításakor törlődik.

A hatókörbe tartozó szolgáltatásokat az őket létrehozó tároló szünteti meg. Ha egy hatókörhöz tartozó szolgáltatás jön létre a gyökértartályban, a szolgáltatás élettartama hatékonyan előlép egyetlen példányúvá, mert azt csak a gyökértartály bocsátja el az alkalmazás vagy a kiszolgáló leállításakor. A szolgáltatási hatókörök érvényesítése ezeket a helyzeteket akkor észleli, amikor a BuildServiceProvider meg van hívva.

Ha mindig ellenőrizni szeretné a hatóköröket, beleértve az éles környezetben is, konfigurálja a ServiceProviderOptions következőt a gazdagépszerkesztőn UseDefaultServiceProvider :

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

További erőforrások

• ASP.NET Core telepítése Windows operációs rendszeren IIS segítségével
• ASP.NET Core hosztolása Linux alatt Nginx-el
• ASP.NET Core fogadása egy Windows szolgáltatásban