Host Webowy ASP.NET Core

Uwaga

Nie jest to najnowsza wersja tego artykułu. Aby zapoznać się z aktualną wersją, zobacz artykuł w wersji .NET 10.

Ostrzeżenie

Ta wersja ASP.NET Core nie jest już obsługiwana. Aby uzyskać więcej informacji, zobacz zasady pomocy technicznej platformy .NET i platformy .NET Core. Aby zapoznać się z aktualną wersją, zobacz artykuł w wersji .NET 10.

Aplikacje ASP.NET Core konfigurują i uruchamiają hosta. Host jest odpowiedzialny za zarządzanie uruchamianiem i okresem istnienia aplikacji. Co najmniej host konfiguruje serwer i potok przetwarzania żądań. Host może również skonfigurować rejestrowanie, wstrzykiwanie zależności i konfigurację.

W tym artykule opisano serwer WWW, który jest dostępny tylko w celu zapewnienia zgodności wstecznej. Szablony ASP.NET Core tworzą WebApplicationBuilder i WebApplication, które są zalecane w przypadku aplikacji internetowych. Aby uzyskać więcej informacji o WebApplicationBuilder i WebApplication, zobacz Migrowanie z ASP.NET Core w .NET 5 do .NET 6.

Konfigurowanie hosta

Utwórz hosta przy użyciu wystąpienia IWebHostBuilder. To zadanie jest zwykle wykonywane w punkcie wejścia aplikacji, Main czyli metodzie w pliku Program.cs . Typowa aplikacja wywołuje metodę CreateDefaultBuilder , aby rozpocząć konfigurowanie hosta:

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

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

Kod, który wywołuje CreateDefaultBuilder, znajduje się w metodzie o nazwie CreateWebHostBuilder, co oddziela go od kodu w Main, który wywołuje metodę Run na obiekcie konstruktora. Separacja jest wymagana, jeśli używasz narzędzi Entity Framework Core. Narzędzia oczekują znalezienia CreateWebHostBuilder metody, którą mogą wywołać w czasie projektowania w celu skonfigurowania hosta bez uruchamiania aplikacji. Alternatywą jest utworzenie wystąpienia klasy IDesignTimeDBContextfactory. Aby uzyskać więcej informacji, zobacz Design-time DbContext Creation.

Metoda CreateDefaultBuilder wykonuje następujące zadania:

Katalog główny zawartości określa, gdzie host wyszukuje pliki zawartości, takie jak pliki widoku MVC. Gdy aplikacja zostanie uruchomiona z folderu głównego projektu, ten folder jest używany jako katalog główny zawartości. To zachowanie jest domyślne dla programu Visual Studio i nowych szablonów dotnet.

Aby uzyskać więcej informacji na temat konfiguracji aplikacji, zobacz Configuration in ASP.NET Core (Konfiguracja w programie ASP.NET Core).

Uwaga

Alternatywą dla użycia metody statycznej CreateDefaultBuilder jest utworzenie hosta w ASP.NET Core 2.x za pomocą WebHostBuilder.

Podczas konfigurowania hosta można użyć Configure metod i ConfigureServices . Jeśli określono klasę Startup , musi ona zdefiniować metodę Configure . Aby uzyskać więcej informacji, zobacz Uruchamianie aplikacji na platformie ASP.NET Core. Kolejne wywołania ConfigureServices są do siebie dołączane. Wiele wywołań do Configure lub UseStartup w wystąpieniu WebHostBuilder zastępuje wszystkie poprzednie ustawienia.

Metody zastępowania konfiguracji

Można zastąpić i rozszerzyć konfigurację zdefiniowaną przez CreateDefaultBuilder. Użyj metod ConfigureAppConfiguration i ConfigureLogging, oraz innych metod i metod rozszerzeń związanych z IWebHostBuilder.

Oto kilka przykładów:

  • ConfigureAppConfiguration służy do określania innych IConfiguration właściwości aplikacji. Następujące wywołanie metody ConfigureAppConfiguration dodaje delegata, aby uwzględnić konfigurację aplikacji w pliku appsettings.xml. ConfigureAppConfiguration może być wywoływany wiele razy. Ta konfiguracja nie ma zastosowania do hosta (na przykład adresów URL serwera lub środowiska). Aby uzyskać więcej informacji, zobacz sekcję Wartości konfiguracji hosta .

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

  • Następujące ConfigureLogging wywołanie dodaje delegata w celu skonfigurowania minimalnego poziomu rejestrowania (SetMinimumLevel) na LogLevel. To ustawienie zastępuje ustawienia w pliku appsettings.Development.json (LogLevel.Debug) i plikuappsettings.Production.json (LogLevel.Error) skonfigurowanego przez metodę CreateDefaultBuilder . ConfigureLogging może być wywoływany wiele razy.

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

  • Następujące wywołanie ConfigureKestrel zastępuje domyślny Limits.MaxRequestBodySize ustanowiony na 30 000 000 bajtów podczas konfigurowania Kestrel przy użyciu metody CreateDefaultBuilder:

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

Ustawianie wartości konfiguracji hosta sieci Web

Wystąpienie WebHostBuilder opiera się na następujących podejściach do ustawiania wartości konfiguracji hosta:

  • Konfiguracja konstruktora hostów, która zawiera zmienne środowiskowe używające formatu ASPNETCORE_{configurationKey}. Na przykład ASPNETCORE_ENVIRONMENT.

  • Rozszerzenia, takie jak UseContentRoot i UseConfiguration. Aby uzyskać więcej informacji, zobacz Zastępowanie konfiguracji hosta sieci Web.

  • Metoda UseSetting i skojarzony klucz. Po ustawieniu wartości za pomocą UseSettingparametru wartość jest ustawiana jako ciąg, niezależnie od typu.

Host używa tej opcji, która jako ostatnia ustawi wartość. Aby uzyskać więcej informacji, zobacz Zastępowanie konfiguracji hosta sieci Web.

Nazwa aplikacji

Definiuje nazwę zestawu, który zawiera punkt wejścia dla aplikacji.

Klucz: applicationName
Typ: ciąg
Ustawienie domyślne: nazwa zestawu, który ma punkt wejścia aplikacji.
Skonfiguruj za pomocą: UseSetting
Zmienna środowiskowa: ASPNETCORE_APPLICATIONNAME

Właściwość IWebHostEnvironment.ApplicationName jest ustawiana automatycznie, gdy metoda UseStartup lub Configure jest wywoływana podczas budowy hosta. Aby jawnie ustawić wartość, użyj ApplicationKey pola .

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

Przechwytywanie błędów uruchamiania

Steruje przechwytywaniem błędów uruchamiania.

Klucz: captureStartupErrors
Typ: bool (true lub 1)
Domyślna: false. Jeśli aplikacja działa w tle pod Kestrel IIS, wartość domyślna to true.
Ustaw za pomocą: CaptureStartupErrors
Zmienna środowiskowa: ASPNETCORE_CAPTURESTARTUPERRORS

Kiedy wartość jest ustawiona na false, błędy podczas uruchamiania powodują zakończenie działania hosta. Gdy jest ustawiona wartość true, host przechwytuje wyjątki podczas uruchamiania i próbuje uruchomić serwer.

WebHost.CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)

Katalog główny zawartości

Określa, gdzie ASP.NET Core rozpoczyna wyszukiwanie plików zawartości.

Klucz: contentRoot
Typ: ciąg
Ustawienie domyślne: folder zawierający zestaw aplikacji.
Ustaw przy użyciu: UseContentRoot
Zmienna środowiskowa: ASPNETCORE_CONTENTROOT

Główny katalog zawartości jest również używany jako ścieżka podstawowa katalogu głównego sieci Web. Jeśli ścieżka główna zawartości nie istnieje, host nie uruchomi się.

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

Aby uzyskać więcej informacji, zobacz:

Szczegółowe błędy

Określa, czy przechwytywać szczegółowe błędy.

Klucz: detailedErrors
Typ: bool (true lub 1)
Ustawienie domyślne: false
Ustaw przy użyciu: UseSetting
Zmienna środowiskowa: ASPNETCORE_DETAILEDERRORS

Po włączeniu (lub gdy wartość Środowisko jest ustawiona na Development), aplikacja przechwytuje szczegółowe wyjątki.

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

Środowisko

Ustawia środowisko aplikacji.

Klucz: environment
Typ: ciąg
Ustawienie domyślne: Production
Ustaw przy użyciu: UseEnvironment
Zmienna środowiskowa: ASPNETCORE_ENVIRONMENT

Środowisko można ustawić na dowolną wartość. Zdefiniowane przez platformę wartości obejmują Development, Stagingi Production. Wartości nie są czułe na wielkość liter.

Domyślnie środowisko jest odczytywane ze zmiennej środowiskowej ASPNETCORE_ENVIRONMENT . W przypadku korzystania z programu Visual Studio zmienne środowiskowe można ustawić w pliku launchSettings.json . Aby uzyskać więcej informacji, zobacz ASP.NET Core runtime environments (Środowiska uruchomieniowe ASP.NET Core).

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

Organizowanie spotkań startupów

Zapewnia ciąg znaków oddzielonych średnikami, zawierający zestawy startowe do wczytania przy uruchomieniu hostingu.

Klucz: hostingStartupAssemblies
Typ: ciąg
Ustawienie domyślne: pusty ciąg.
Ustaw przy użyciu: UseSetting
Zmienna środowiskowa: ASPNETCORE_HOSTINGSTARTUPASSEMBLIES

Mimo że wartość konfiguracji jest domyślnie pusta, zestawy uruchamiania hostingu zawsze zawierają zestaw aplikacji. Gdy zestawy startowe są udostępniane, dodawane są do zestawu aplikacji w celu ładowania, gdy aplikacja kompiluje swoje wspólne usługi podczas uruchamiania.

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

Port HTTPS

Ustawia port HTTPS na potrzeby przekierowania, jeśli zostanie nawiązane połączenie inne niż HTTPS.

Klucz: https_port
Typ: ciąg
Ustawienie domyślne: Brak wartości domyślnej.
Ustaw przy użyciu: UseSetting
Zmienna środowiskowa: ASPNETCORE_HTTPS_PORT

To ustawienie jest używane w wymuszaniu protokołu HTTPS. To ustawienie nie powoduje, że serwer nasłuchuje na wyznaczonym porcie. Oznacza to, że możliwe jest przypadkowe przekierowanie żądań do nieużywanego portu.

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

Hostowanie zestawów wykluczania uruchamiania

Udostępnia rozdzielany średnikami ciąg zestawów uruchomieniowych hostingu do wykluczenia podczas jego uruchamiania.

Klucz: hostingStartupExcludeAssemblies
Typ: ciąg
Ustawienie domyślne: pusty ciąg.
Ustaw przy użyciu: UseSetting
Zmienna środowiskowa: ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIES

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

Preferuj adresy URL hostingu

Wskazuje, czy host powinien nasłuchiwać na adresach URL skonfigurowanych za pomocą WebHostBuilder zamiast adresów URL skonfigurowanych za pomocą implementacji IServer.

Klucz: preferHostingUrls
Typ: bool (true lub 1)
Ustawienie domyślne: false
Skonfiguruj za pomocą: PreferHostingUrls
Zmienna środowiskowa: ASPNETCORE_PREFERHOSTINGURLS

WebHost.CreateDefaultBuilder(args)
    .PreferHostingUrls(true)

Zapobieganie uruchamianiu hostingu

Zapobiega automatycznemu ładowaniu zestawów startowych hostingu, w tym tych skonfigurowanych przez zestaw aplikacji. Więcej informacji można znaleźć w temacie Korzystanie z hostowania zestawów startowych na platformie ASP.NET Core.

Klucz: preventHostingStartup
Typ: bool (true lub 1)
Ustawienie domyślne: false
Ustaw przy użyciu: UseSetting
Zmienna środowiskowa: ASPNETCORE_PREVENTHOSTINGSTARTUP

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

Adresy URL serwera

Wskazuje adresy IP lub adresy hostów z portami i protokołami, na których serwer powinien nasłuchiwać żądań.

Klucz: urls
Typ: ciąg
Ustawienie domyślne: http://localhost:5000
Ustaw przy użyciu: UseUrls
Zmienna środowiskowa: ASPNETCORE_URLS

Ustaw na rozdzieloną ; średnikami listę prefiksów adresów URL, na które serwer powinien odpowiadać. Na przykład http://localhost:123. Użyj gwiazdki wieloznacznej *, aby wskazać, że serwer powinien nasłuchiwać żądań na dowolnym adresie IP lub nazwie hosta używając określonego portu i protokołu (na przykład http://*:5000). Protokół (http:// lub https://) musi być dołączony do każdego adresu URL. Obsługiwane formaty różnią się między serwerami.

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

Kestrel ma własny interfejs API konfiguracji punktu końcowego. Aby uzyskać więcej informacji, zobacz Konfigurowanie punktów końcowych dla serwera sieciowego ASP.NET CoreKestrel.

Limit czasowy zamknięcia

Określa czas oczekiwania na zamknięcie hosta sieci Web.

Klucz: shutdownTimeoutSeconds
Typ: int
Ustawienie domyślne: 5 sekund
Ustaw przy użyciu: UseShutdownTimeout
Zmienna środowiskowa: ASPNETCORE_SHUTDOWNTIMEOUTSECONDS

Mimo że klucz akceptuje int z UseSetting (na przykład .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10")), metoda rozszerzenia UseShutdownTimeout przyjmuje parametr TimeSpan.

W czasie oczekiwania host sieci Web:

  • Wyzwalacze ApplicationStopping.
  • Próbuje zatrzymać hostowane usługi i rejestrować wszelkie błędy dotyczące usług, które nie mogą się zatrzymać.

Jeśli okres limitu czasu wygaśnie przed zatrzymaniem wszystkich hostowanych usług, pozostałe aktywne usługi zostaną zatrzymane, gdy aplikacja zostaje zamknięta. Usługi są zatrzymywane nawet wtedy, gdy nadal są przetwarzane. Jeśli usługi wymagają więcej czasu na zatrzymanie, zwiększ limit czasu.

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

Zestaw startowy

Określa zestaw do wyszukiwania Startup klasy.

Klucz: startupAssembly
Typ: ciąg
Ustawienie domyślne: zestaw aplikacji.
Ustaw przy użyciu: UseStartup
Zmienna środowiskowa: ASPNETCORE_STARTUPASSEMBLY

Możesz odwołać się do zestawu według nazwy (string) lub typu (TStartup). Jeśli wywoływano wiele UseStartup metod, ostatnie wywołanie ma pierwszeństwo.

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

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

katalog główny strony internetowej

Ustawia ścieżkę względną do zasobów statycznych aplikacji.

Klucz: webroot
Typ: ciąg
Ustawienie domyślne: wwwroot
Ustaw przy użyciu: UseWebRoot
Zmienna środowiskowa: ASPNETCORE_WEBROOT

Ścieżka do {content root}/wwwroot musi istnieć. Jeśli ścieżka nie istnieje, zostanie użyty bezczynny dostawca plików.

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

Aby uzyskać więcej informacji, zobacz:

Przesłanianie konfiguracji hosta sieci Web

Konfigurowanie hosta sieci Web za pomocą konfiguracji aplikacji w programie ASP.NET Core .

W poniższym przykładzie konfiguracja hosta jest opcjonalnie określona w pliku hostsettings.json . Argumenty wiersza polecenia mogą zastąpić dowolną konfigurację załadowaną z pliku hostsettings.json . Skonfigurowana konfiguracja jest używana do konfiguracji hosta za pomocą metody UseConfiguration. IWebHostBuilder konfiguracja jest dodawana do konfiguracji aplikacji, ale odwrotnie nie jest prawdziwe. Metoda ConfigureAppConfiguration nie ma wpływu na konfigurację IWebHostBuilder .

Przesłanianie konfiguracji dostarczonej za pomocą UseUrls konfiguracji hostsettings.json , a następnie konfiguracji argumentu wiersza polecenia:

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!"));
            });
    }
}

Zawartość pliku hostsettings.json :

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

Uwaga

Metoda UseConfiguration kopiuje tylko klucze z dostarczonej IConfiguration do konfiguracji konstruktora hosta. Ustawianie właściwości reloadOnChange: true dla plików ustawień JSON, INI i XML nie ma wpływu.

Aby określić uruchomienie hosta w określonym adresie URL, żądana wartość może zostać przekazana z wiersza polecenia podczas wykonywania polecenia dotnet run. Argument wiersza polecenia zastępuje urls wartość z pliku hostsettings.json , a serwer nasłuchuje na porcie 8080:

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

Zarządzanie hostem sieci Web

Aby zarządzać hostem sieci Web, należy użyć następujących metod.

Run

Metoda Run uruchamia aplikację internetową i blokuje wątek wywołujący do czasu zamknięcia hosta:

host.Run();

Start

Uruchom hosta w sposób nieblokujący, wywołując jego Start metodę:

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

Jeśli do metody Start jest przekazywana lista adresów URL, metoda nasłuchuje na określonych adresach 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();
}

Aplikacja może zainicjować i uruchomić nowy host ze wstępnie skonfigurowanymi wartościami domyślnymi metody CreateDefaultBuilder przy użyciu statycznej metody pomocniczej. Te metody uruchamiania serwera bez wyjścia konsoli używają metody WaitForShutdown, która czeka na przerwę (Ctrl+C/SIGINT (Windows), Ctrl+C (macOS) lub SIGTERM).

Start(RequestDelegate app)

Uruchom hosta za pomocą polecenia RequestDelegate:

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

Prześlij żądanie w przeglądarce do http://localhost:5000 adresu URL, aby otrzymać odpowiedź "Hello World!" Metoda WaitForShutdown blokuje się do momentu wydania przerwy (Ctrl-C/SIGINT lub SIGTERM). Aplikacja wyświetla Console.WriteLine komunikat i czeka na naciśnięcie klawisza, aby zakończyć działanie.

Start(ciąg znaków adresu URL, RequestDelegate app)

Uruchom hosta przy użyciu adresu URL i 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();
}

Daje taki sam wynik jak Start(RequestDelegate app), z wyjątkiem, że aplikacja odpowiada na http://localhost:8080 adres URL.

Start(Action<IRouteBuilder> routeBuilder)

Uruchom hosta, zaczynając od wystąpienia IRouteBuilder (Microsoft.AspNetCore.Routing), które korzysta z middleware routingu:

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

Użyj następujących żądań przeglądarki w przykładzie:

Zażądaj Odpowiedź
http://localhost:5000/hello/Martin Witaj, Martin!
http://localhost:5000/buenosdias/Catrina Buenos dias, Catrina!
http://localhost:5000/throw/ooops! Zgłasza wyjątek o treści "oops!"
http://localhost:5000/throw Zgłasza wyjątek z ciągiem "Uh oh!"
http://localhost:5000/Sante/Kevin Sante, Kevin!
http://localhost:5000 Cześć ludzie!

Metoda WaitForShutdown blokuje się do momentu wydania przerwy (Ctrl-C/SIGINT lub SIGTERM). Aplikacja wyświetla Console.WriteLine komunikat i czeka na naciśnięcie klawisza, aby zakończyć działanie.

Start(string adresu URL, Action<IRouteBuilder> routeBuilder)

Uruchom hosta, zaczynając od adresu URL i wystąpienia 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();
}

Tworzy taki sam wynik jak Start(Action<IRouteBuilder routeBuilder>), z wyjątkiem, że aplikacja odpowiada na http://localhost:8080 adres URL.

StartWith(Action<IApplicationBuilder> app)

Uruchom hosta, zaczynając od delegata, który konfiguruje element 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();
}

Prześlij żądanie w przeglądarce na http://localhost:5000 URL, aby otrzymać odpowiedź "Hello World!" Metoda WaitForShutdown jest zablokowana do momentu, gdy zostanie wydane przerwanie (Ctrl-C/SIGINT lub SIGTERM). Aplikacja wyświetla Console.WriteLine komunikat i czeka na naciśnięcie klawisza, aby zakończyć działanie.

StartWith(ciąg url, Action<IApplicationBuilder> app)

Uruchom hosta, zaczynając od adresu URL i delegata, który konfiguruje IApplicationBuilderelement :

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

Tworzy taki sam wynik jak StartWith(Action<IApplicationBuilder> app), z wyjątkiem tego, że aplikacja odpowiada na http://localhost:8080 adresie URL.

Korzystanie z interfejsu IWebHostEnvironment

Interfejs IWebHostEnvironment zawiera informacje o środowisku hostingu internetowego aplikacji. Użyj iniekcji konstruktora do uzyskania instancji IWebHostEnvironment, a następnie uzyskaj dostęp do jej właściwości i metod rozszerzenia.

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

Podejście oparte na konwencji może służyć do konfigurowania aplikacji podczas uruchamiania na podstawie środowiska. Alternatywnie wstrzyknij wystąpienie IWebHostEnvironment do konstruktora Startup do użycia w metodzie 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;
    }
}

Uwaga

Oprócz metody rozszerzenia IsDevelopment, IWebHostEnvironment oferuje metody IsStaging, IsProduction i IsEnvironment(string environmentName). Aby uzyskać więcej informacji, zobacz ASP.NET Core runtime environments (Środowiska uruchomieniowe ASP.NET Core).

Usługę IWebHostEnvironment można również wstrzyknąć bezpośrednio do Configure metody konfigurowania potoku przetwarzania:

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

IWebHostEnvironmentmożna implementować w metodzie Invoke podczas tworzenia niestandardowego middleware:

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

Korzystanie z interfejsu IHostApplicationLifetime

IHostApplicationLifetime umożliwia wykonywanie działań po uruchomieniu i zamykaniu. Trzy właściwości interfejsu to tokeny anulowania używane do rejestrowania Action metod definiujących zdarzenia uruchamiania i zamykania.

Token anulowania Trigger
ApplicationStarted Host jest w pełni uruchomiony.
ApplicationStopped Host kończy bezproblemowe zamknięcie. Oczekuje się, że wszystkie żądania zostaną przetworzone. Zamknij bloki do momentu zakończenia tego zdarzenia.
ApplicationStopping Host wykonuje łagodne wyłączenie. Żądania mogą być nadal przetwarzane. Zamknij bloki do momentu zakończenia tego zdarzenia. 
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
    }
}

Metoda StopApplication żąda zakończenia aplikacji. Następująca klasa używa StopApplication do bezpiecznego zamknięcia aplikacji, gdy wywoływana jest metoda klasy Shutdown.

public class MyClass
{
    private readonly IHostApplicationLifetime _appLifetime;

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

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

Konfigurowanie walidacji zakresu

Metoda CreateDefaultBuilder ustawia właściwość ValidateScopes na true, jeśli środowisko aplikacji to Development.

Gdy ValidateScopes jest ustawiona wartość true, domyślny dostawca usług przeprowadza kontrole w celu zweryfikowania:

  • Usługi o określonym zakresie nie są bezpośrednio ani pośrednio rozwiązywane przez głównego dostawcę usług.
  • Usługi zakresowe nie są bezpośrednio ani pośrednio wstrzykiwane do singletonów.

Dostawca usługi głównej jest tworzony, gdy metoda BuildServiceProvider jest wywoływana. Okres istnienia głównego dostawcy usług odpowiada okresowi istnienia aplikacji/serwera, gdy dostawca rozpoczyna działanie wraz z aplikacją i jest zakończony po zamknięciu aplikacji.

Kontener, który utworzył usługi o określonym zakresie, również likwiduje te usługi. Jeśli usługa o określonym zakresie jest tworzona w kontenerze głównym, cykl życia usługi jest skutecznie promowany do singleton. Kontener główny usuwa usługę tylko wtedy, gdy aplikacja/serwer zostanie zamknięta. Sprawdzanie poprawności zakresów usługi przechwytuje te sytuacje, gdy BuildServiceProvider jest wywoływane.

Aby zawsze weryfikować zakresy, w tym w Production środowisku, skonfiguruj obiekt ServiceProviderOptions metodą UseDefaultServiceProvider na budowniczym hosta.

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

Treści powiązane

  • Last updated on