ASP.NET Core-WebhostASP.NET Core Web Host

Durch ASP.NET Core-Apps kann ein Host gestartet und konfiguriert werden.ASP.NET Core apps configure and launch a host. Der Host ist verantwortlich für das Starten der App und das Verwalten der Lebensdauer.The host is responsible for app startup and lifetime management. Der Host konfiguriert mindestens einen Server und eine Pipeline für die Anforderungsverarbeitung.At a minimum, the host configures a server and a request processing pipeline. Der Host kann auch die Protokollierung, die Dependency Injection und die Konfiguration einrichten.The host can also set up logging, dependency injection, and configuration.

In diesem Artikel wird der Webhost behandelt, der nur aus Gründen der Abwärtskompatibilität verfügbar bleibt.This article covers the Web Host, which remains available only for backward compatibility. Für alle App-Typen wird der Generische Host empfohlen.The Generic Host is recommended for all app types.

In diesem Artikel wird der Webhost behandelt, der zum Hosten von Web-Apps dient.This article covers the Web Host, which is for hosting web apps. Verwenden Sie für andere Arten von Apps den generischen Host.For other kinds of apps, use the Generic Host.

Einrichten eines HostsSet up a host

Erstellen Sie einen Host mithilfe einer Instanz von IWebHostBuilder.Create a host using an instance of IWebHostBuilder. Dies wird üblicherweise am Einstiegspunkt der App (die Main-Methode) durchgeführt.This is typically performed in the app's entry point, the Main method.

In den Projektvorlagen befindet Main sich in Program.cs.In the project templates, Main is located in Program.cs. Eine typische App ruft CreateDefaultBuilder auf, um die Einrichtung eines Hosts zu starten:A typical app calls CreateDefaultBuilder to start setting up a host:

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

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

Der Code, der CreateDefaultBuilder aufruft, befindet sich in einer Methode namens CreateWebHostBuilder, die diesen Code von dem Code in Main trennt, der Run im Generatorobjekt aufruft.The code that calls CreateDefaultBuilder is in a method named CreateWebHostBuilder, which separates it from the code in Main that calls Run on the builder object. Diese Trennung ist erforderlich, wenn Sie Entity Framework Core-Tools verwenden.This separation is required if you use Entity Framework Core tools. Die Tools erwarten eine CreateWebHostBuilder-Methode, die sie zur Entwurfszeit aufrufen können, um den Host zu konfigurieren, ohne die App auszuführen.The tools expect to find a CreateWebHostBuilder method that they can call at design time to configure the host without running the app. Eine Alternative dazu ist die Implementierung vonIDesignTimeDbContextFactory.An alternative is to implement IDesignTimeDbContextFactory. Weitere Informationen finden Sie unter DbContext-Instanzerstellung zur Entwurfszeit.For more information, see Design-time DbContext Creation.

CreateDefaultBuilder führt folgende Ausgaben aus:CreateDefaultBuilder performs the following tasks:

Die durch CreateDefaultBuilder definierte Konfiguration kann von ConfigureAppConfiguration, ConfigureLogging und anderen Methoden sowie Erweiterungsmethoden von IWebHostBuilder überschrieben und erweitert werden.The configuration defined by CreateDefaultBuilder can be overridden and augmented by ConfigureAppConfiguration, ConfigureLogging, and other methods and extension methods of IWebHostBuilder. Es folgen einige Beispiele:A few examples follow:

  • ConfigureAppConfiguration wird zum zusätzlichen Festlegen von IConfiguration für die App verwendet.ConfigureAppConfiguration is used to specify additional IConfiguration for the app. Der folgende ConfigureAppConfiguration-Aufruf fügt einen Delegaten hinzu, um die App-Konfiguration in die Datei appsettings.xml einzufügen.The following ConfigureAppConfiguration call adds a delegate to include app configuration in the appsettings.xml file. ConfigureAppConfiguration kann mehrmals aufgerufen werden.ConfigureAppConfiguration may be called multiple times. Beachten Sie, dass diese Konfiguration nicht für den Host gilt (z.B. Server-URLs oder Umgebungen).Note that this configuration doesn't apply to the host (for example, server URLs or environment). Informationen finden Sie im Abschnitt Hostkonfigurationswerte.See the Host configuration values section.

    WebHost.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration((hostingContext, config) =>
        {
            config.AddXmlFile("appsettings.xml", optional: true, reloadOnChange: true);
        })
        ...
    
  • Der folgende ConfigureLogging-Aufruf fügt einen Delegaten hinzu, um den Mindestprotokolliergrad (SetMinimumLevel) auf LogLevel.Warning zu konfigurieren.The following ConfigureLogging call adds a delegate to configure the minimum logging level (SetMinimumLevel) to LogLevel.Warning. Diese Einstellung überschreibt die Einstellungen in appsettings.Development.json (LogLevel.Debug) und appsettings.Production.json (LogLevel.Error), die durch CreateDefaultBuilder konfiguriert wurden.This setting overrides the settings in appsettings.Development.json (LogLevel.Debug) and appsettings.Production.json (LogLevel.Error) configured by CreateDefaultBuilder. ConfigureLogging kann mehrmals aufgerufen werden.ConfigureLogging may be called multiple times.

    WebHost.CreateDefaultBuilder(args)
        .ConfigureLogging(logging => 
        {
            logging.SetMinimumLevel(LogLevel.Warning);
        })
        ...
    
  • Der folgende Aufruf von ConfigureKestrel überschreibt den Standardwert von 30.000.000 Bytes von Limits.MaxRequestBodySize, der festgelegt wurde, als Kestrel durch CreateDefaultBuilder konfiguriert wurde:The following call to ConfigureKestrel overrides the default Limits.MaxRequestBodySize of 30,000,000 bytes established when Kestrel was configured by CreateDefaultBuilder:

    WebHost.CreateDefaultBuilder(args)
        .ConfigureKestrel((context, options) =>
        {
            options.Limits.MaxRequestBodySize = 20000000;
        });
    
  • Der folgende Aufruf von UseKestrel überschreibt den Standardwert von 30.000.000 Bytes von Limits.MaxRequestBodySize, der festgelegt wurde, als Kestrel durch CreateDefaultBuilder konfiguriert wurde:The following call to UseKestrel overrides the default Limits.MaxRequestBodySize of 30,000,000 bytes established when Kestrel was configured by CreateDefaultBuilder:

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

Das Inhaltsstammverzeichnis bestimmt, wo der Host nach Inhaltsdateien (z.B. MVC-Ansichtsdateien) sucht.The content root determines where the host searches for content files, such as MVC view files. Wenn die App aus dem Stammordner des Projekts gestartet wird, wird dieser als Inhaltsstammverzeichnis verwendet.When the app is started from the project's root folder, the project's root folder is used as the content root. Dies ist die Standardeinstellung in Visual Studio und für neue .NET-Vorlagen.This is the default used in Visual Studio and the dotnet new templates.

Weitere Informationen zur App-Konfiguration finden Sie unter Konfiguration in ASP.NET Core.For more information on app configuration, see Konfiguration in ASP.NET Core.

Hinweis

Als Alternative zur Verwendung der statischen CreateDefaultBuilder-Methode ist das Erstellen eines Hosts von WebHostBuilder ein unterstützter Ansatz mit ASP.NET Core 2.x.As an alternative to using the static CreateDefaultBuilder method, creating a host from WebHostBuilder is a supported approach with ASP.NET Core 2.x.

Beim Einrichten eines Hosts können die Methoden Configure und ConfigureServices bereitgestellt werden.When setting up a host, Configure and ConfigureServices methods can be provided. Wenn eine Startup-Klasse angegeben wird, muss diese eine Configure-Methode definieren.If a Startup class is specified, it must define a Configure method. Weitere Informationen finden Sie unter Anwendungsstart in ASP.NET Core.For more information, see Anwendungsstart in ASP.NET Core. Wenn ConfigureServices mehrmals aufgerufen wird, werden diese Aufrufe einander angefügt.Multiple calls to ConfigureServices append to one another. Durch mehrere Aufrufe von Configure oder UseStartup in WebHostBuilder werden die vorherigen Einstellungen ersetzt.Multiple calls to Configure or UseStartup on the WebHostBuilder replace previous settings.

HostkonfigurationswerteHost configuration values

WebHostBuilder basiert auf folgenden Ansätzen, um die Hostkonfigurationswerte festzulegen:WebHostBuilder relies on the following approaches to set the host configuration values:

  • Hostbuilderkonfigurationen, die Umgebungsvariablen im Format ASPNETCORE_{configurationKey} enthalten.Host builder configuration, which includes environment variables with the format ASPNETCORE_{configurationKey}. Beispielsweise ASPNETCORE_ENVIRONMENT.For example, ASPNETCORE_ENVIRONMENT.
  • Erweiterungen wie UseContentRoot und UseConfiguration (siehe Abschnitt Überschreiben der Konfiguration).Extensions such as UseContentRoot and UseConfiguration (see the Override configuration section).
  • UseSetting und der zugeordnete Schlüssel.UseSetting and the associated key. Wenn Sie einen Wert mit UseSetting festlegen, wird dieser unabhängig vom Typ als Zeichenfolge festgelegt.When setting a value with UseSetting, the value is set as a string regardless of the type.

Der Host verwendet die Option, die zuletzt einen Wert festlegt.The host uses whichever option sets a value last. Weitere Informationen finden Sie im nächsten Abschnitt unter Außerkraftsetzen der Konfiguration.For more information, see Override configuration in the next section.

Anwendungsschlüssel (Name)Application Key (Name)

Die Eigenschaft IWebHostEnvironment.ApplicationName wird automatisch festgelegt, wenn UseStartup oder Configure während der Hosterstellung aufgerufen wird.The IWebHostEnvironment.ApplicationName property is automatically set when UseStartup or Configure is called during host construction. Der Wert wird auf den Namen der Assembly festgelegt, die den Einstiegspunkt der App enthält.The value is set to the name of the assembly containing the app's entry point. Um den Wert explizit festzulegen, verwenden Sie den WebHostDefaults.ApplicationKey:To set the value explicitly, use the WebHostDefaults.ApplicationKey:

Die Eigenschaft IHostingEnvironment.ApplicationName wird automatisch festgelegt, wenn UseStartup oder Configure während der Hosterstellung aufgerufen wird.The IHostingEnvironment.ApplicationName property is automatically set when UseStartup or Configure is called during host construction. Der Wert wird auf den Namen der Assembly festgelegt, die den Einstiegspunkt der App enthält.The value is set to the name of the assembly containing the app's entry point. Um den Wert explizit festzulegen, verwenden Sie den WebHostDefaults.ApplicationKey:To set the value explicitly, use the WebHostDefaults.ApplicationKey:

Schlüssel: AnwendungsnameKey: applicationName
Typ: ZeichenfolgeType: string
Standardwert: Der Name der Assembly, die den Einstiegspunkt der App enthält.Default: The name of the assembly containing the app's entry point.
Festlegen mit: UseSettingSet using: UseSetting
Umgebungsvariable: ASPNETCORE_APPLICATIONNAMEEnvironment variable: ASPNETCORE_APPLICATIONNAME

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

Erfassen von StartfehlernCapture Startup Errors

Diese Einstellung steuert das Erfassen von Startfehlern.This setting controls the capture of startup errors.

Schlüssel: captureStartupErrorsKey: captureStartupErrors
Typ: Boolesch (true or 1)Type: bool (true or 1)
Standard: Die Standardeinstellung ist gleich false, es sei denn, die App wird mit Kestrel hinter IIS ausgeführt, dann ist sie gleich true.Default: Defaults to false unless the app runs with Kestrel behind IIS, where the default is true.
Festlegen mit: CaptureStartupErrorsSet using: CaptureStartupErrors
Umgebungsvariable: ASPNETCORE_CAPTURESTARTUPERRORSEnvironment variable: ASPNETCORE_CAPTURESTARTUPERRORS

Wenn diese false ist, führen Fehler beim Start zum Beenden des Hosts.When false, errors during startup result in the host exiting. Wenn diese true ist, erfasst der Host Ausnahmen während des Starts und versucht, den Server zu starten.When true, the host captures exceptions during startup and attempts to start the server.

WebHost.CreateDefaultBuilder(args)
    .CaptureStartupErrors(true)

InhaltsstammverzeichnisContent root

Diese Einstellung bestimmt, wo ASP.NET mit der Suche nach Inhaltsdateien beginnt.This setting determines where ASP.NET Core begins searching for content files.

Schlüssel: contentRootKey: contentRoot
Typ: ZeichenfolgeType: string
Standard: Entspricht standardmäßig dem Ordner, in dem die App-Assembly gespeichert ist.Default: Defaults to the folder where the app assembly resides.
Festlegen mit: UseContentRootSet using: UseContentRoot
Umgebungsvariable: ASPNETCORE_CONTENTROOTEnvironment variable: ASPNETCORE_CONTENTROOT

Das Inhaltsstammverzeichnis wird ebenfalls als Basispfad für das Webstammverzeichnis verwendet.The content root is also used as the base path for the web root. Wenn der Pfad des Inhaltsstammverzeichnisses nicht vorhanden ist, kann der Host nicht gestartet werden.If the content root path doesn't exist, the host fails to start.

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

Weitere Informationen finden Sie unter:For more information, see:

Detaillierte FehlerDetailed Errors

Bestimmt, ob detaillierte Fehler erfasst werden sollen.Determines if detailed errors should be captured.

Schlüssel: detailedErrorsKey: detailedErrors
Typ: Boolesch (true or 1)Type: bool (true or 1)
Standard: FALSEDefault: false
Festlegen mit: UseSettingSet using: UseSetting
Umgebungsvariable: ASPNETCORE_DETAILEDERRORSEnvironment variable: ASPNETCORE_DETAILEDERRORS

Wenn diese Einstellung aktiviert ist (oder die Umgebung auf Development festgelegt ist), erfasst die App detaillierte Ausnahmen.When enabled (or when the Environment is set to Development), the app captures detailed exceptions.

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

UmgebungEnvironment

Legt die Umgebung der App fest.Sets the app's environment.

Schlüssel: environmentKey: environment
Typ: ZeichenfolgeType: string
Standard: ProduktionDefault: Production
Festlegen mit: UseEnvironmentSet using: UseEnvironment
Umgebungsvariable: ASPNETCORE_ENVIRONMENTEnvironment variable: ASPNETCORE_ENVIRONMENT

Die Umgebung kann auf einen beliebigen Wert festgelegt werden.The environment can be set to any value. Zu den durch Frameworks definierten Werten zählen Development, Staging und Production.Framework-defined values include Development, Staging, and Production. Die Groß-/Kleinschreibung wird bei Werten nicht beachtet.Values aren't case sensitive. Standardmäßig wird die Umgebung aus der ASPNETCORE_ENVIRONMENT-Umgebungsvariablen gelesen.By default, the Environment is read from the ASPNETCORE_ENVIRONMENT environment variable. Wenn Sie Visual Studio verwenden, werden Umgebungsvariablen möglicherweise in der Datei launchSettings.json festgelegt.When using Visual Studio, environment variables may be set in the launchSettings.json file. Weitere Informationen finden Sie unter Verwenden von mehreren Umgebungen in ASP.NET Core.For more information, see Verwenden von mehreren Umgebungen in ASP.NET Core.

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

HostingstartassemblysHosting Startup Assemblies

Legt die Hostingstartassemblys der App fest.Sets the app's hosting startup assemblies.

Schlüssel: hostingStartupAssembliesKey: hostingStartupAssemblies
Typ: ZeichenfolgeType: string
Standard: Leere ZeichenfolgeDefault: Empty string
Festlegen mit: UseSettingSet using: UseSetting
Umgebungsvariable: ASPNETCORE_HOSTINGSTARTUPASSEMBLIESEnvironment variable: ASPNETCORE_HOSTINGSTARTUPASSEMBLIES

Eine durch Semikolons getrennte Zeichenfolge der Hostingstartassemblys, die beim Start geladen werden soll.A semicolon-delimited string of hosting startup assemblies to load on startup.

Obwohl der Konfigurationswert standardmäßig auf eine leere Zeichenfolge festgelegt ist, enthalten die Hostingstartassemblys immer die Assembly der App.Although the configuration value defaults to an empty string, the hosting startup assemblies always include the app's assembly. Wenn Hostingstartassemblys bereitgestellt werden, werden diese zur Assembly der App hinzugefügt, damit diese geladen werden, wenn die App während des Starts die allgemeinen Dienste erstellt.When hosting startup assemblies are provided, they're added to the app's assembly for loading when the app builds its common services during startup.

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

HTTPS-AnschlussHTTPS Port

Legen Sie den HTTPS-Umleitungsport fest.Set the HTTPS redirect port. Wird in Erzwingen von HTTPS verwendet.Used in enforcing HTTPS.

Schlüssel: https_port Typ: Zeichenfolge Standardwert: Es ist kein Standardwert festgelegt.Key: https_port Type: string Default: A default value isn't set. Festlegen mit: UseSetting Umgebungsvariable: ASPNETCORE_HTTPS_PORTSet using: UseSetting Environment variable: ASPNETCORE_HTTPS_PORT

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

Auszuschließende HostingstartassemblysHosting Startup Exclude Assemblies

Eine durch Semikolons getrennte Zeichenfolge der Hostingstartassemblys, die beim Start ausgeschlossen werden sollen.A semicolon-delimited string of hosting startup assemblies to exclude on startup.

Schlüssel: hostingStartupExcludeAssembliesKey: hostingStartupExcludeAssemblies
Typ: ZeichenfolgeType: string
Standard: Leere ZeichenfolgeDefault: Empty string
Festlegen mit: UseSettingSet using: UseSetting
Umgebungsvariable: ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIESEnvironment variable: ASPNETCORE_HOSTINGSTARTUPEXCLUDEASSEMBLIES

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

Bevorzugen von Hosting-URLsPrefer Hosting URLs

Gibt an, ob der Hosts den URLs lauschen soll, die mit WebHostBuilder konfiguriert wurden, statt denen, die mit der IServer-Implementierung konfiguriert wurden.Indicates whether the host should listen on the URLs configured with the WebHostBuilder instead of those configured with the IServer implementation.

Schlüssel: preferHostingUrlsKey: preferHostingUrls
Typ: Boolesch (true or 1)Type: bool (true or 1)
Standard: TRUEDefault: true
Festlegen mit: PreferHostingUrlsSet using: PreferHostingUrls
Umgebungsvariable: ASPNETCORE_PREFERHOSTINGURLSEnvironment variable: ASPNETCORE_PREFERHOSTINGURLS

WebHost.CreateDefaultBuilder(args)
    .PreferHostingUrls(false)

Verhindern des HostingstartsPrevent Hosting Startup

Verhindert das automatische Laden der Hostingstartassemblys, einschließlich denen, die von der Assembly der App konfiguriert wurden.Prevents the automatic loading of hosting startup assemblies, including hosting startup assemblies configured by the app's assembly. Weitere Informationen finden Sie unter Verwenden von Hostingstartassemblys in ASP.NET Core.For more information, see Verwenden von Hostingstartassemblys in ASP.NET Core.

Schlüssel: preventHostingStartupKey: preventHostingStartup
Typ: Boolesch (true or 1)Type: bool (true or 1)
Standard: FALSEDefault: false
Festlegen mit: UseSettingSet using: UseSetting
Umgebungsvariable: ASPNETCORE_PREVENTHOSTINGSTARTUPEnvironment variable: ASPNETCORE_PREVENTHOSTINGSTARTUP

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

Server-URLsServer URLs

Gibt die IP-Adressen oder Hostadressen mit Ports und Protokollen an, denen der Server für Anforderungen lauschen soll.Indicates the IP addresses or host addresses with ports and protocols that the server should listen on for requests.

Schlüssel: urlsKey: urls
Typ: ZeichenfolgeType: string
Standard: http://localhost:5000Default: http://localhost:5000
Festlegen mit: UseUrlsSet using: UseUrls
Umgebungsvariable: ASPNETCORE_URLSEnvironment variable: ASPNETCORE_URLS

Legt die Einstellung auf eine durch Semikolons (;) getrennte Liste von URL-Präfixen fest, auf die der Server reagieren soll.Set to a semicolon-separated (;) list of URL prefixes to which the server should respond. Beispielsweise http://localhost:123.For example, http://localhost:123. Verwenden Sie *, um anzugeben, dass der Server mithilfe des angegebenen Ports und Protokolls (z.B. http://*:5000) den Anfragen aller IP-Adressen oder Hostnamen lauschen soll.Use "*" to indicate that the server should listen for requests on any IP address or hostname using the specified port and protocol (for example, http://*:5000). Das Protokoll (http:// oder https://) muss in jeder URL enthalten sein.The protocol (http:// or https://) must be included with each URL. Die unterstützten Formate variieren bei den verschiedenen Servern.Supported formats vary among servers.

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

Kestrel verfügt über eine eigene API für die Endpunktkonfiguration.Kestrel has its own endpoint configuration API. Weitere Informationen finden Sie unter Implementierung des Webservers Kestrel in ASP.NET Core.For more information, see Implementierung des Webservers Kestrel in ASP.NET Core.

Timeout beim HerunterfahrenShutdown Timeout

Gibt die Wartezeit an, bis der Webhost heruntergefahren wird.Specifies the amount of time to wait for Web Host to shut down.

Schlüssel: shutdownTimeoutSecondsKey: shutdownTimeoutSeconds
Typ: Ganze ZahlType: int
Standard: 5Default: 5
Festlegen mit: UseShutdownTimeoutSet using: UseShutdownTimeout
Umgebungsvariable: ASPNETCORE_SHUTDOWNTIMEOUTSECONDSEnvironment variable: ASPNETCORE_SHUTDOWNTIMEOUTSECONDS

Obwohl der Schlüssel eine ganze Zahl mit UseSetting (z.B. .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10")) akzeptiert, akzeptiert die Erweiterungsmethode UseShutdownTimeout ein TimeSpan-Objekt.Although the key accepts an int with UseSetting (for example, .UseSetting(WebHostDefaults.ShutdownTimeoutKey, "10")), the UseShutdownTimeout extension method takes a TimeSpan.

Während des Zeitlimits, verhält sich das Hosting folgendermaßen:During the timeout period, hosting:

Wenn das Zeitlimit abläuft bevor alle gehosteten Dienste beendet sind, werden alle verbleibenden aktiven Dienste beendet, wenn die App herunterfährt.If the timeout period expires before all of the hosted services stop, any remaining active services are stopped when the app shuts down. Die Dienste werden beendet, selbst wenn die Verarbeitung noch nicht abgeschlossen ist.The services stop even if they haven't finished processing. Wenn die Dienste mehr Zeit zum Beenden benötigen, sollten Sie das Zeitlimit erhöhen.If services require additional time to stop, increase the timeout.

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

StartassemblyStartup Assembly

Bestimmt die Assembly, die nach der Startup-Klasse suchen soll.Determines the assembly to search for the Startup class.

Schlüssel: startupAssemblyKey: startupAssembly
Typ: ZeichenfolgeType: string
Standard: Die Assembly der AppDefault: The app's assembly
Festlegen mit: UseStartupSet using: UseStartup
Umgebungsvariable: ASPNETCORE_STARTUPASSEMBLYEnvironment variable: ASPNETCORE_STARTUPASSEMBLY

Es kann auf die Assembly nach Name (string) oder Typ (TStartup) verwiesen werden.The assembly by name (string) or type (TStartup) can be referenced. Wenn mehrere UseStartup-Methoden aufgerufen werden, hat die letzte Vorrang.If multiple UseStartup methods are called, the last one takes precedence.

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

WebstammverzeichnisWeb root

Legt den relativen Pfad für die statischen Objekte der App fest.Sets the relative path to the app's static assets.

Schlüssel: webrootKey: webroot
Typ: ZeichenfolgeType: string
Standard: Der Standardwert ist wwwroot.Default: The default is wwwroot. Der Pfad zu {Inhaltsstammverzeichnis}/wwwroot muss vorhanden sein.The path to {content root}/wwwroot must exist. Wenn der Pfad nicht vorhanden ist, wird ein Dateianbieter ohne Funktion verwendet.If the path doesn't exist, a no-op file provider is used.
Festlegen mit: UseWebRootSet using: UseWebRoot
Umgebungsvariable: ASPNETCORE_WEBROOTEnvironment variable: ASPNETCORE_WEBROOT

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

Weitere Informationen finden Sie unter:For more information, see:

Außerkraftsetzen der KonfigurationOverride configuration

Verwenden Sie die Konfiguration, um den Webhost zu konfigurieren.Use Configuration to configure Web Host. Im folgenden Beispiel wird die Hostkonfiguration optional in einer hostsettings.json-Datei angegeben.In the following example, host configuration is optionally specified in a hostsettings.json file. Jede Konfiguration, die aus der Datei hostsettings.json geladen wird, kann von Befehlszeilenargumenten überschrieben werden.Any configuration loaded from the hostsettings.json file may be overridden by command-line arguments. Die erstellte Konfiguration (in config) wird verwendet, um den Host mit UseConfiguration zu konfigurieren.The built configuration (in config) is used to configure the host with UseConfiguration. Der Konfiguration der App wird die IWebHostBuilder-Konfiguration hinzugefügt, das Gegenteil gilt jedoch nicht. ConfigureAppConfiguration hat keinen Einfluss auf die IWebHostBuilder-Konfiguration.IWebHostBuilder configuration is added to the app's configuration, but the converse isn't true—ConfigureAppConfiguration doesn't affect the IWebHostBuilder configuration.

Das Überschreiben der Konfiguration wird von UseUrls bereitgestellt, hierbei kommt die Konfiguration hostsettings.json zuerst und anschließend die Konfiguration der Befehlszeilenargumente:Overriding the configuration provided by UseUrls with hostsettings.json config first, command-line argument config second:

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:hostsettings.json:

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

Hinweis

UseConfiguration kopiert nur Schlüssel aus der bereitgestellten IConfiguration-Schnittstelle in die Konfiguration des Host-Generators.UseConfiguration only copies keys from the provided IConfiguration to the host builder configuration. Daher hat das Festlegen von reloadOnChange: true für JSON-, INI- und XML-Einstellungsdateien keine Auswirkung.Therefore, setting reloadOnChange: true for JSON, INI, and XML settings files has no effect.

Damit der Host auf einer bestimmten URL ausgeführt wird, kann der gewünschte Wert von der Befehlszeile aus übergeben werden, wenn dotnet run ausgeführt wird.To specify the host run on a particular URL, the desired value can be passed in from a command prompt when executing dotnet run. Das Befehlszeilenargument überschreibt den urls-Wert der hostsettings.json-Datei, und der Server lauscht Port 8080:The command-line argument overrides the urls value from the hostsettings.json file, and the server listens on port 8080:

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

Verwalten des HostsManage the host

RunRun

Die Run-Methode startet die Web-App und blockiert den aufrufenden Thread, bis der Host heruntergefahren wird:The Run method starts the web app and blocks the calling thread until the host is shut down:

host.Run();

StartenStart

Führen Sie den Host auf nicht blockierende Weise aus, indem Sie dessen Start-Methode aufrufen:Run the host in a non-blocking manner by calling its Start method:

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

Wenn eine Liste mit URLs an die Start-Methode übergeben wird, lauscht diese den angegebenen URLs:If a list of URLs is passed to the Start method, it listens on the URLs specified:

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

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

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

Die App kann einen neuen Host, der die vorab konfigurierten Standardwerte von CreateDefaultBuilder verwendet, mithilfe einer statischen Hilfsmethode initialisieren und starten.The app can initialize and start a new host using the pre-configured defaults of CreateDefaultBuilder using a static convenience method. Diese Methoden starten den Server ohne Konsolenausgabe und mit der WaitForShutdown-Methode, die auf eine Unterbrechung wartet (STRG+C/SIGINT oder SIGTERM):These methods start the server without console output and with WaitForShutdown wait for a break (Ctrl-C/SIGINT or SIGTERM):

Start(RequestDelegate app)Start(RequestDelegate app)

Beginnend mit einer RequestDelegate-Funktion:Start with a RequestDelegate:

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

Stellen Sie im Browser eine Anforderung an http://localhost:5000, um die Antwort „Hello World!“ zu erhalten.Make a request in the browser to http://localhost:5000 to receive the response "Hello World!" WaitForShutdown blockiert, bis eine Unterbrechung (STRG+C/SIGINT oder SIGTERM) ausgelöst wird.WaitForShutdown blocks until a break (Ctrl-C/SIGINT or SIGTERM) is issued. Die App zeigt die Console.WriteLine-Meldung an und wartet, bis diese durch Tastendruck beendet wird.The app displays the Console.WriteLine message and waits for a keypress to exit.

Start(string url, RequestDelegate app)Start(string url, RequestDelegate app)

Beginnend mit einer URL und RequestDelegate:Start with a URL and 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();
}

Erzeugt das gleiche Ergebnis wie Start(RequestDelegate app) , mit dem Unterschied, dass die App auf http://localhost:8080 reagiert.Produces the same result as Start(RequestDelegate app), except the app responds on http://localhost:8080.

Start(Action<IRouteBuilder> routeBuilder)Start(Action<IRouteBuilder> routeBuilder)

Verwenden Sie eine Instanz von IRouteBuilder (Microsoft.AspNetCore.Routing), um Routingmiddleware zu verwenden:Use an instance of IRouteBuilder (Microsoft.AspNetCore.Routing) to use routing middleware:

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

Verwenden Sie folgende Browseranforderung mit dem Beispiel:Use the following browser requests with the example:

AnforderungRequest AntwortResponse
http://localhost:5000/hello/Martin Hello, Martin!Hello, Martin!
http://localhost:5000/buenosdias/Catrina Buenos dias, Catrina!Buenos dias, Catrina!
http://localhost:5000/throw/ooops! Löst eine Ausnahme mit der Zeichenfolge „ooops!“ aus.Throws an exception with string "ooops!"
http://localhost:5000/throw Löst eine Ausnahme mit der Zeichenfolge „Uh oh!“ aus.Throws an exception with string "Uh oh!"
http://localhost:5000/Sante/Kevin Sante, Kevin!Sante, Kevin!
http://localhost:5000 Hello World!Hello World!

WaitForShutdown blockiert, bis eine Unterbrechung (STRG+C/SIGINT oder SIGTERM) ausgelöst wird.WaitForShutdown blocks until a break (Ctrl-C/SIGINT or SIGTERM) is issued. Die App zeigt die Console.WriteLine-Meldung an und wartet, bis diese durch Tastendruck beendet wird.The app displays the Console.WriteLine message and waits for a keypress to exit.

Start(string url, Action<IRouteBuilder> routeBuilder)Start(string url, Action<IRouteBuilder> routeBuilder)

Verwenden Sie eine URL und eine Instanz von IRouteBuilder:Use a URL and an instance of 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();
}

Erzeugt das gleiche Ergebnis wie Start(Action<IRouteBuilder> routeBuilder) , mit dem Unterschied, dass die App auf http://localhost:8080 reagiert.Produces the same result as Start(Action<IRouteBuilder> routeBuilder), except the app responds at http://localhost:8080.

StartWith(Action<IApplicationBuilder> app)StartWith(Action<IApplicationBuilder> app)

Stellen Sie einen Delegaten bereit, um eine IApplicationBuilder-Schnittstelle zu konfigurieren:Provide a delegate to configure an 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();
}

Stellen Sie im Browser eine Anforderung an http://localhost:5000, um die Antwort „Hello World!“ zu erhalten.Make a request in the browser to http://localhost:5000 to receive the response "Hello World!" WaitForShutdown blockiert, bis eine Unterbrechung (STRG+C/SIGINT oder SIGTERM) ausgelöst wird.WaitForShutdown blocks until a break (Ctrl-C/SIGINT or SIGTERM) is issued. Die App zeigt die Console.WriteLine-Meldung an und wartet, bis diese durch Tastendruck beendet wird.The app displays the Console.WriteLine message and waits for a keypress to exit.

StartWith(string url, Action<IApplicationBuilder> app)StartWith(string url, Action<IApplicationBuilder> app)

Stellen Sie eine URL und einen Delegaten bereit, um eine IApplicationBuilder-Schnittstelle zu konfigurieren:Provide a URL and a delegate to configure an 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();
}

Erzeugt das gleiche Ergebnis wie StartWith(Action<IApplicationBuilder> app) , mit dem Unterschied, dass die App auf http://localhost:8080 reagiert.Produces the same result as StartWith(Action<IApplicationBuilder> app), except the app responds on http://localhost:8080.

IWebHostEnvironment-SchnittstelleIWebHostEnvironment interface

Die IWebHostEnvironment-Schnittstelle stellt Informationen über die Webhostingumgebung der App bereit.The IWebHostEnvironment interface provides information about the app's web hosting environment. Verwenden Sie Constructor Injection zum Abrufen der IWebHostEnvironment-Schnittstelle, um deren Eigenschaften und Erweiterungsmethoden zu verwenden:Use constructor injection to obtain the IWebHostEnvironment in order to use its properties and extension methods:

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

Ein konventionsbasierter Ansatz kann verwendet werden, um die App beim Start je nach Umgebung zu konfigurieren.A convention-based approach can be used to configure the app at startup based on the environment. Fügen Sie alternativ die IWebHostEnvironment-Schnittstelle in den Startup-Konstruktor für die Verwendung in ConfigureServices ein:Alternatively, inject the IWebHostEnvironment into the Startup constructor for use in 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;
    }
}

Hinweis

Zusätzlich zur IsDevelopment-Erweiterungsmethode stellt die IWebHostEnvironment-Schnittstelle die IsStaging-, IsProduction- und IsEnvironment(string environmentName)-Methoden bereit.In addition to the IsDevelopment extension method, IWebHostEnvironment offers IsStaging, IsProduction, and IsEnvironment(string environmentName) methods. Weitere Informationen finden Sie unter Verwenden von mehreren Umgebungen in ASP.NET Core.For more information, see Verwenden von mehreren Umgebungen in ASP.NET Core.

Der IWebHostEnvironment-Dienst kann ebenfalls direkt in die Configure-Methode eingefügt werden, um die Verarbeitungspipeline einzurichten:The IWebHostEnvironment service can also be injected directly into the Configure method for setting up the processing pipeline:

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 kann in die Invoke-Methode eingefügt werden, wenn eine benutzerdefinierte Middleware erstellt wird:IWebHostEnvironment can be injected into the Invoke method when creating custom 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;
}

IHostingEnvironment-SchnittstelleIHostingEnvironment interface

Die IHostingEnvironment-Schnittstelle stellt Informationen über die Webhostingumgebung der App bereit.The IHostingEnvironment interface provides information about the app's web hosting environment. Verwenden Sie Constructor Injection zum Abrufen der IHostingEnvironment-Schnittstelle, um deren Eigenschaften und Erweiterungsmethoden zu verwenden:Use constructor injection to obtain the IHostingEnvironment in order to use its properties and extension methods:

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

Ein konventionsbasierter Ansatz kann verwendet werden, um die App beim Start je nach Umgebung zu konfigurieren.A convention-based approach can be used to configure the app at startup based on the environment. Fügen Sie alternativ die IHostingEnvironment-Schnittstelle in den Startup-Konstruktor für die Verwendung in ConfigureServices ein:Alternatively, inject the IHostingEnvironment into the Startup constructor for use in 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;
    }
}

Hinweis

Zusätzlich zur IsDevelopment-Erweiterungsmethode stellt die IHostingEnvironment-Schnittstelle die IsStaging-, IsProduction- und IsEnvironment(string environmentName)-Methoden bereit.In addition to the IsDevelopment extension method, IHostingEnvironment offers IsStaging, IsProduction, and IsEnvironment(string environmentName) methods. Weitere Informationen finden Sie unter Verwenden von mehreren Umgebungen in ASP.NET Core.For more information, see Verwenden von mehreren Umgebungen in ASP.NET Core.

Der IHostingEnvironment-Dienst kann ebenfalls direkt in die Configure-Methode eingefügt werden, um die Verarbeitungspipeline einzurichten:The IHostingEnvironment service can also be injected directly into the Configure method for setting up the processing pipeline:

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 kann in die Invoke-Methode eingefügt werden, wenn eine benutzerdefinierte Middleware erstellt wird:IHostingEnvironment can be injected into the Invoke method when creating custom middleware:

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

IHostApplicationLifetime-SchnittstelleIHostApplicationLifetime interface

IHostApplicationLifetime ermöglicht Aktivitäten nach dem Starten und beim Herunterfahren.IHostApplicationLifetime allows for post-startup and shutdown activities. Bei drei der Eigenschaften der Schnittstelle handelt es sich um Abbruchtokens, die zum Registrieren von Action-Methoden verwendet werden, durch die Ereignisse beim Starten und Herunterfahren definiert werden.Three properties on the interface are cancellation tokens used to register Action methods that define startup and shutdown events.

AbbruchtokenCancellation Token Wird ausgelöst, wenn…Triggered when…
ApplicationStarted Der Host vollständig gestartet wurde.The host has fully started.
ApplicationStopped Der Host ein ordnungsgemäßes Herunterfahren abschließt.The host is completing a graceful shutdown. Alle Anforderungen sollten verarbeitet worden sein.All requests should be processed. Das Herunterfahren wird blockiert, bis das Ereignis abgeschlossen ist.Shutdown blocks until this event completes.
ApplicationStopping Der Host ein ordnungsgemäßes Herunterfahren ausführt.The host is performing a graceful shutdown. Anforderungen möglicherweise noch verarbeitet werden.Requests may still be processing. Das Herunterfahren wird blockiert, bis das Ereignis abgeschlossen ist.Shutdown blocks until this event completes.
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 fordert das Beenden der App an.StopApplication requests termination of the app. Die folgende Klasse verwendet StopApplication, um eine App ordnungsgemäß herunterzufahren, wenn die Shutdown-Methode der Klasse aufgerufen wird:The following class uses StopApplication to gracefully shut down an app when the class's Shutdown method is called:

public class MyClass
{
    private readonly IHostApplicationLifetime _appLifetime;

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

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

IApplicationLifetime-SchnittstelleIApplicationLifetime interface

IApplicationLifetime ermöglicht Aktivitäten nach dem Starten und beim Herunterfahren.IApplicationLifetime allows for post-startup and shutdown activities. Bei drei der Eigenschaften der Schnittstelle handelt es sich um Abbruchtokens, die zum Registrieren von Action-Methoden verwendet werden, durch die Ereignisse beim Starten und Herunterfahren definiert werden.Three properties on the interface are cancellation tokens used to register Action methods that define startup and shutdown events.

AbbruchtokenCancellation Token Wird ausgelöst, wenn…Triggered when…
ApplicationStartedApplicationStarted Der Host vollständig gestartet wurde.The host has fully started.
ApplicationStoppedApplicationStopped Der Host ein ordnungsgemäßes Herunterfahren abschließt.The host is completing a graceful shutdown. Alle Anforderungen sollten verarbeitet worden sein.All requests should be processed. Das Herunterfahren wird blockiert, bis das Ereignis abgeschlossen ist.Shutdown blocks until this event completes.
ApplicationStoppingApplicationStopping Der Host ein ordnungsgemäßes Herunterfahren ausführt.The host is performing a graceful shutdown. Anforderungen möglicherweise noch verarbeitet werden.Requests may still be processing. Das Herunterfahren wird blockiert, bis das Ereignis abgeschlossen ist.Shutdown blocks until this event completes.
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 fordert das Beenden der Anwendung an.StopApplication requests termination of the app. Die folgende Klasse verwendet StopApplication, um eine App ordnungsgemäß herunterzufahren, wenn die Shutdown-Methode der Klasse aufgerufen wird:The following class uses StopApplication to gracefully shut down an app when the class's Shutdown method is called:

public class MyClass
{
    private readonly IApplicationLifetime _appLifetime;

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

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

BereichsvalidierungScope validation

CreateDefaultBuilder legt ServiceProviderOptions.ValidateScopes auf true fest, wenn die Umgebung der App „Entwicklung“ ist.CreateDefaultBuilder sets ServiceProviderOptions.ValidateScopes to true if the app's environment is Development.

Wenn ValidateScopes auf true festgelegt wird, führt der Standarddienstanbieter Überprüfungen durch, um sicherzustellen, dass:When ValidateScopes is set to true, the default service provider performs checks to verify that:

  • Bereichsbezogene Dienste nicht direkt oder indirekt vom Stammdienstanbieter aufgelöst werdenScoped services aren't directly or indirectly resolved from the root service provider.
  • Bereichsbezogene Dienste nicht direkt oder indirekt in Singletons eingefügt werdenScoped services aren't directly or indirectly injected into singletons.

Der Stammdienstanbieter wird erstellt, wenn BuildServiceProvider aufgerufen wird.The root service provider is created when BuildServiceProvider is called. Die Lebensdauer des Stammdienstanbieters entspricht der Lebensdauer der App/des Servers, wenn der Anbieter mit der App erstellt wird und verworfen wird, wenn die App beendet wird.The root service provider's lifetime corresponds to the app/server's lifetime when the provider starts with the app and is disposed when the app shuts down.

Bereichsbezogene Dienste werden von dem Container verworfen, der sie erstellt hat.Scoped services are disposed by the container that created them. Wenn ein bereichsbezogener Dienst im Stammcontainer erstellt wird, wird die Lebensdauer effektiv auf Singleton heraufgestuft, da er nur vom Stammcontainer verworfen wird, wenn die App/der Server heruntergefahren wird.If a scoped service is created in the root container, the service's lifetime is effectively promoted to singleton because it's only disposed by the root container when app/server is shut down. Die Überprüfung bereichsbezogener Dienste erfasst diese Situationen, wenn BuildServiceProvider aufgerufen wird.Validating service scopes catches these situations when BuildServiceProvider is called.

Konfigurieren Sie ServiceProviderOptions mit UseDefaultServiceProvider auf dem Hostbuilder, um Bereiche immer zu validieren, auch in der Produktionsumgebung:To always validate scopes, including in the Production environment, configure the ServiceProviderOptions with UseDefaultServiceProvider on the host builder:

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

Zusätzliche RessourcenAdditional resources