Generischer .NET-Host in ASP.NET Core

Dieser Artikel stellt Informationen zur Verwendung des generischen .NET-Hosts in ASP.NET Core bereit. Informationen zur Verwendung des generischen .NET-Hosts in Konsolen-Apps finden Sie unter Generischer .NET-Host.

Grundlegendes zur Rolle des Hosts

Ein Host ist ein Objekt, das die Ressourcen einer Anwendung kapselt, z. B.:

• Abhängigkeitsinjektion
• Logging
• Configuration
• IHostedService-Implementierungen

Wenn ein Host gestartet wird, ruft er die StartAsync Methode auf jeder IHostedService Instanz auf, die in der Kollektion gehosteter Dienste des Dienstcontainers registriert ist. In einer Web-App ist eine der IHostedService-Implementierungen ein Webdienst, der eine HTTP-Server-Implementierung startet.

Indem alle interdependenten Ressourcen der App in ein einzelnes Objekt eingeschlossen werden, ermöglicht der Host die Steuerung des Anwendungsstarts und das ordnungsgemäße Herunterfahren.

Einrichten eines Hosts

Der Host wird in der Regel durch Code in der Program.cs Datei konfiguriert, erstellt und ausgeführt.

await Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddHostedService<SampleHostedService>();
    })
    .Build()
    .RunAsync();

await Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup<Startup>();
    })
    .Build()
    .RunAsync();

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
               services.AddHostedService<Worker>();
            });
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Konfigurieren von Standard-Generator-Einstellungen

Die CreateDefaultBuilder Methode führt die folgenden Aufgaben aus:

• Legt das Inhaltsstammverzeichnis auf den Pfad fest, der von GetCurrentDirectory zurückgegeben wird.

• Lädt die Hostkonfiguration aus den folgenden Quellen:

  • Umgebungsvariablen mit Präfix DOTNET_
  • Befehlszeilenargumente

• Lädt die App-Konfiguration in der folgenden Reihenfolge:

  • appsettings.json Datei
  • appsettings.{Environment}.json-Datei
  • Benutzergeheimnisse (werden geladen, wenn die App in der Development Umgebung mit der Entree-Assembly ausgeführt wird.)
  • Umgebungsvariablen
  • Befehlszeilenargumente

• Fügt die folgenden Protokollierungsanbieter hinzu:

  • Console
  • Debug
  • EventSource
  • EventLog (nur bei Ausführung unter Windows)

• Aktiviert Bereichsvalidierung und Abhängigkeitsvalidierung, wenn die Umgebung Development.

Die ConfigureWebHostDefaults Methode führt die folgenden Aufgaben aus:

• Lädt Hostkonfiguration aus Umgebungsvariablen mit dem Präfix ASPNETCORE_.

• Legt Kestrel als Webserver fest und richtet ihn mithilfe der Hosting-Konfigurationsanbieter der App ein. Informationen zu den Standardoptionen des Kestrel-Servers finden Sie im Abschnitt Optionen für den ASP.NET Core Kestrel-Webserver konfigurieren.

• Fügt Middleware zum Filtern von Hosts hinzu.

• Fügt Forwarded Headers Middleware hinzu, wenn die Eigenschaft ASPNETCORE_FORWARDEDHEADERS_ENABLED auf true gesetzt ist.

• Ermöglicht die Integration von IIS. Informationen zu den IIS-Standardoptionen finden Sie unter Hosten von ASP.NET Core unter Windows mit IIS.

Informationen zum Außerkraftsetzen von Standard-Generator-Einstellungen finden Sie unter Konfigurieren von Einstellungen für alle App-Typen und Konfigurieren von Einstellungen für Web-Apps weiter unten in diesem Artikel.

Von Frameworks bereitgestellte Dienste

Der .NET Generic Host registriert automatisch die folgenden Dienste:

• IHostApplicationLifetime
• IHostLifetime
• IHostEnvironment/IWebHostEnvironment

Weitere Informationen zu vom Framework bereitgestellten Diensten finden Sie unter Abhängigkeitsinjektion in ASP.NET Core.

IHostApplicationLifetime

Injizieren Sie den IHostApplicationLifetime-Dienst (ehemals IApplicationLifetime) in eine beliebige Klasse, um Aufgaben nach dem Start und beim ordnungsgemäßen Schließen zu bearbeiten. Drei Eigenschaften auf der Schnittstelle sind Abbruchtoken, die zum Registrieren von App-Start- und App-Stopp-Ereignishandlermethoden verwendet werden. Die Schnittstelle umfasst außerdem eine StopApplication-Methode, mit der Apps ein ordnungsgemäßes Herunterfahren anfordern können.

Beim ordnungsgemäßen Herunterfahren führt der Host die folgenden Aufgaben aus:

• Er löst die ApplicationStopping-Ereignishandler aus, wodurch die App Logik ausführen kann, bevor das Herunterfahren eingeleitet wird.

• Stoppt den Server, wodurch neue Verbindungen verhindert werden. Der Server wartet darauf, dass Anfragen auf bestehenden Verbindungen abgeschlossen werden, solange es das Shutdown-Timeout erlaubt. Der Server sendet den Connection-Close-Header für weitere Anforderungen auf vorhandenen Verbindungen.

• Die ApplicationStopped-Ereignishandler werden ausgelöst, wodurch die App Logik ausführen lässt, nachdem die Anwendung heruntergefahren wurde.

Das folgende Beispiel zeigt eine IHostedService-Implementierung, die IHostApplicationLifetime-Ereignishandler registriert:

public class HostApplicationLifetimeEventsHostedService : IHostedService
{
    private readonly IHostApplicationLifetime _hostApplicationLifetime;

    public HostApplicationLifetimeEventsHostedService(
        IHostApplicationLifetime hostApplicationLifetime)
        => _hostApplicationLifetime = hostApplicationLifetime;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _hostApplicationLifetime.ApplicationStarted.Register(OnStarted);
        _hostApplicationLifetime.ApplicationStopping.Register(OnStopping);
        _hostApplicationLifetime.ApplicationStopped.Register(OnStopped);

        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
        => Task.CompletedTask;

    private void OnStarted()
    {
        // ...
    }

    private void OnStopping()
    {
        // ...
    }

    private void OnStopped()
    {
        // ...
    }
}

internal class LifetimeEventsHostedService : IHostedService
{
    private readonly ILogger _logger;
    private readonly IHostApplicationLifetime _appLifetime;

    public LifetimeEventsHostedService(
        ILogger<LifetimeEventsHostedService> logger, 
        IHostApplicationLifetime appLifetime)
    {
        _logger = logger;
        _appLifetime = appLifetime;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _appLifetime.ApplicationStarted.Register(OnStarted);
        _appLifetime.ApplicationStopping.Register(OnStopping);
        _appLifetime.ApplicationStopped.Register(OnStopped);

        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
    }

    private void OnStarted()
    {
        _logger.LogInformation("OnStarted has been called.");

        // Perform post-startup activities here
    }

    private void OnStopping()
    {
        _logger.LogInformation("OnStopping has been called.");

        // Perform on-stopping activities here
    }

    private void OnStopped()
    {
        _logger.LogInformation("OnStopped has been called.");

        // Perform post-stopped activities here
    }
}

IHostLifetime

Die IHostLifetime-Implementierung steuert, wann der Host gestartet und beendet wird. Die zuletzt registrierte Implementierung wird verwendet.

Microsoft.Extensions.Hosting.Internal.ConsoleLifetime ist die IHostLifetime-Standardimplementierung.

Die ConsoleLifetime Methode führt die folgenden Aufgaben aus:

• Lauscht auf STRG+C/SIGINT (Windows), STRG+C (macOS) oder SIGTERM und ruft StopApplication auf, die den Herunterfahrvorgang starten.

• Hebt die Blockierung von Erweiterungen auf, z. B. durch das Ausführen der Methoden RunAsync und WaitForShutdownAsync.

IHostEnvironment (IWebHostEnvironment)

Fügt den IHostEnvironment-Dienst in eine Klasse ein, um Informationen über die folgenden Einstellungen abzurufen:

• ApplicationName
• EnvironmentName
• ContentRootPath

Web-Apps implementieren die IWebHostEnvironment-Schnittstelle, die von IHostEnvironment erbt und WebRootPath hinzufügt.

Einrichten der Hostkonfiguration

Die Hostkonfiguration wird für die Eigenschaften der IHostEnvironment-Implementierung verwendet.

Die Hostkonfiguration ist über die Configuration Eigenschaft innerhalb der ConfigureAppConfiguration Methode verfügbar. Nach ConfigureAppConfiguration wird HostBuilderContext.Configuration durch die App-Konfiguration ersetzt.

Rufen Sie die ConfigureHostConfiguration-Methode auf der IHostBuilder-Instanz auf, um die Hostkonfiguration hinzuzufügen. ConfigureHostConfiguration kann mehrfach mit additiven Ergebnissen aufgerufen werden. Der Host verwendet die Option, die zuletzt einen Wert für einen bestimmten Schlüssel festlegt.

CreateDefaultBuilder enthält den Umgebungsvariablenanbieter mit dem Präfix DOTNET_ und den Befehlszeilenargumenten. Für Web-Apps wird der Umgebungsvariablenanbieter mit dem Präfix ASPNETCORE_ hinzugefügt. Das Präfix wird entfernt, wenn die Umgebungsvariablen gelesen werden. Der Wert der Umgebungsvariable für ASPNETCORE_ENVIRONMENT wird z. B. der Hostkonfigurationswert für den environment-Schlüssel.

Im folgenden Beispiel wird eine Hostkonfiguration erstellt:

Host.CreateDefaultBuilder(args)
    .ConfigureHostConfiguration(hostConfig =>
    {
        hostConfig.SetBasePath(Directory.GetCurrentDirectory());
        hostConfig.AddJsonFile("hostsettings.json", optional: true);
        hostConfig.AddEnvironmentVariables(prefix: "PREFIX_");
        hostConfig.AddCommandLine(args);
    });

// using Microsoft.Extensions.Configuration;

Host.CreateDefaultBuilder(args)
    .ConfigureHostConfiguration(configHost =>
    {
        configHost.SetBasePath(Directory.GetCurrentDirectory());
        configHost.AddJsonFile("hostsettings.json", optional: true);
        configHost.AddEnvironmentVariables(prefix: "PREFIX_");
        configHost.AddCommandLine(args);
    });

Erstellen der App-Konfiguration

Die App-Konfiguration wird durch Aufrufen der ConfigureAppConfiguration Methode für die IHostBuilder Instanz erstellt. ConfigureAppConfiguration kann mehrfach mit additiven Ergebnissen aufgerufen werden. Die App verwendet die Option, die zuletzt einen Wert für einen bestimmten Schlüssel festlegt.

Die von ConfigureAppConfiguration erstellte Konfiguration ist in der Eigenschaft Configuration für nachfolgende Vorgänge und als Dienst von DI verfügbar. Die Hostkonfiguration wird ebenfalls der App-Konfiguration hinzugefügt.

Weitere Informationen finden Sie unter Konfiguration in ASP.NET Core.

Konfigurieren von Einstellungen für alle App-Typen

In diesem Abschnitt werden Hosteinstellungen aufgeführt, die sowohl für HTTP- als auch für Nicht-HTTP-Workloads gelten.

Standardmäßig können die zum Konfigurieren dieser Einstellungen verwendeten Umgebungsvariablen ein DOTNET_- oder ASPNETCORE_-Präfix aufweisen, das in der folgenden Liste der Einstellungen als Platzhalter {PREFIX_} angezeigt wird.

Weitere Informationen finden Sie unter Konfigurieren von Standard-Generator-Einstellungen und -Konfiguration: Umgebungsvariablen.

Anwendungsname

Definiert den Namen der Assembly, die den Einstiegspunkt für die Anwendung enthält.

Schlüssel: applicationName
Typ: Zeichenfolge
Standard: Der Name der Assembly mit dem App-Einstiegspunkt.
Festlegen mit: Umgebungsvariable
Umgebungsvariable: {PREFIX_}APPLICATIONNAME

Die ApplicationName Eigenschaft wird während der Erstellung des Hosts aus der Hostkonfiguration festgelegt.

Inhaltsstamm

Bestimmt, wo der Host die Suche nach Inhaltsdateien beginnt.

Schlüssel: contentRoot
Typ: Zeichenfolge
Standard: Der Ordner, in dem die App-Assembly gespeichert ist.
Set using: Umgebungsvariable oder UseContentRoot auf IHostBuilder
Umgebungsvariable: {PREFIX_}CONTENTROOT

Die ContentRootPath Eigenschaft gibt an, wo der Host mit der Suche beginnt. Wenn der Pfad nicht vorhanden ist, kann der Host nicht gestartet werden.

Host.CreateDefaultBuilder(args)
    .UseContentRoot("/path/to/content/root")
    // ...

Host.CreateDefaultBuilder(args)
    .UseContentRoot("c:\\content-root")
    //...

Weitere Informationen finden Sie unter:

• Grundlagen: Inhaltsstamm
• Webstammverzeichnis

Umgebungsname

Stellt einen Namen für die Umgebung bereit.

Schlüssel: environment
Typ: Zeichenfolge
Standard:Production
Einstellen über: Umgebungsvariable oder Aufruf von UseEnvironment in IHostBuilder
Umgebungsvariable: {PREFIX_}ENVIRONMENT

Die Eigenschaft EnvironmentName kann auf einen beliebigen Wert festgelegt werden. Zu den durch Frameworks definierten Werten zählen Development, Staging und Production. Werte sind nicht groß-/kleinsensitiv.

Host.CreateDefaultBuilder(args)
    .UseEnvironment("Development")
    // ...

Host.CreateDefaultBuilder(args)
    .UseEnvironment("Development")
    //...

Timeout für das Herunterfahren

Gibt die Zeitspanne an, die auf das Herunterfahren des Hosts wartet.

Schlüssel: shutdownTimeoutSeconds
Typ: int
Standard: 30 Sekunden (In .NET 5.0 und früher ist der Standardwert 5 Sekunden.)
Festgelegt durch: Umgebungsvariable oder HostOptions
Umgebungsvariable: {PREFIX_}SHUTDOWNTIMEOUTSECONDS

Die ShutdownTimeout-Eigenschaft legt das Timeout für StopAsync fest. Der Standardwert ist 30 Sekunden.

Während des Timeouts der Host:

• Er löst ApplicationStopping aus.
• Er versucht, gehostete Dienste zu beenden und protokolliert Fehler für Dienste, die nicht beendet werden können.

Wenn der Timeoutzeitraum abläuft, bevor alle gehosteten Dienste beendet werden, werden alle verbleibenden aktiven Dienste beendet, wenn die App heruntergefahren wird. Die Dienste werden auch dann beendet, wenn sie noch verarbeitet werden. Wenn die Dienste mehr Zeit zum Beenden benötigen, erhöhen Sie den Timeoutwert.

Host.CreateDefaultBuilder(args)
    .ConfigureServices((hostContext, services) =>
    {
        services.Configure<HostOptions>(options =>
        {
            options.ShutdownTimeout = TimeSpan.FromSeconds(20);
        });
    });

Host.CreateDefaultBuilder(args)
    .ConfigureServices((hostContext, services) =>
    {
        services.Configure<HostOptions>(option =>
        {
            option.ShutdownTimeout = System.TimeSpan.FromSeconds(20);
        });
    });

Konfigurieren von Einstellungen für Web-Apps

Einige Hosteinstellungen gelten nur für HTTP-Workloads. Standardmäßig können die zum Konfigurieren dieser Einstellungen verwendeten Umgebungsvariablen ein DOTNET_- oder ASPNETCORE_-Präfix aufweisen, das in der folgenden Liste der Einstellungen als Platzhalter {PREFIX_} angezeigt wird.

Für diese Einstellungen sind Erweiterungsmethoden in IWebHostBuilder verfügbar. In den Codebeispielen, die zeigen, wie Sie die Erweiterungsmethoden aufrufen können, wird davon ausgegangen, dass webBuilder eine Instanz von IWebHostBuilder ist. Sehen Sie hierzu das folgende Beispiel:

Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(webBuilder =>
    {
        // ...
    });

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.CaptureStartupErrors(true);
            webBuilder.UseStartup<Startup>();
        });

Erfassen von Startfehlern

Steuert die Erfassung von Startfehlern.

Schlüssel: captureStartupErrors
Typ: bool (true/1 oder false/0)
Standard-: false. Wenn die App hinter Kestrel IIS ausgeführt wird, ist true die Standardeinstellung.
Set using: Konfiguration or CaptureStartupErrors
Umgebungsvariable: {PREFIX_}CAPTURESTARTUPERRORS

Wenn diese false ist, führen Fehler beim Start zum Beenden des Hosts. Wenn diese true ist, erfasst der Host Ausnahmen während des Starts und versucht, den Server zu starten.

webBuilder.CaptureStartupErrors(true);

webBuilder.CaptureStartupErrors(true);

Detaillierte Fehler

Bestimmt, ob detaillierte Fehler erfasst werden sollen.

Schlüssel: detailedErrors
Typ: bool (true/1 oder false/0)
Standard:false
Set using: Configuration or UseSetting
Umgebungsvariable: {PREFIX_}DETAILEDERRORS

Wenn aktiviert oder wenn die Umgebung auf Development festgelegt ist, erfasst die App detaillierte Fehler.

webBuilder.UseSetting(WebHostDefaults.DetailedErrorsKey, "true");

webBuilder.UseSetting(WebHostDefaults.DetailedErrorsKey, "true");

Hostingstartassemblys

Stellt eine durch Semikolons getrennte Zeichenfolge von Hosting-Startup-Assemblies bereit, die beim Start geladen werden.

Schlüssel: hostingStartupAssemblies
Typ: Zeichenfolge
Standard: Leere Zeichenfolge
Festlegen mit: UseSetting
Umgebungsvariable: {PREFIX_}HOSTINGSTARTUPASSEMBLIES

Obwohl der Konfigurationswert standardmäßig auf eine leere Zeichenfolge festgelegt ist, enthalten die Hostingstartassemblys immer die Assembly der App. Wenn Start-Assemblys für das Hosting bereitgestellt werden, werden sie zur Assembly der App hinzugefügt, damit sie beim Starten der App geladen werden können, während die allgemeinen Dienste erstellt werden.

webBuilder.UseSetting(
    WebHostDefaults.HostingStartupAssembliesKey, "assembly1;assembly2");

webBuilder.UseSetting(WebHostDefaults.HostingStartupAssembliesKey, "assembly1;assembly2");

Hosting-Startup schließt Assemblys aus

Stellt eine durch Semikolons getrennte Zeichenfolge von Hosting-Start-Assemblys bereit, die beim Start ausgeschlossen werden sollen.

Schlüssel: hostingStartupExcludeAssemblies
Typ: Zeichenfolge
Standard: Leere Zeichenfolge
Einstellen mit: Konfiguration oder UseSetting
Umgebungsvariable: {PREFIX_}HOSTINGSTARTUPEXCLUDEASSEMBLIES

webBuilder.UseSetting(
    WebHostDefaults.HostingStartupExcludeAssembliesKey, "assembly1;assembly2");

webBuilder.UseSetting(WebHostDefaults.HostingStartupExcludeAssembliesKey, "assembly1;assembly2");

HTTPS-Port

Legt den HTTPS-Port für die Umleitung fest, wenn Sie eine Nicht-HTTPS-Verbindung erhalten.

Schlüssel: https_port
Typ: Zeichenfolge
Standardeinstellung: Keine Standardeinstellung.
Festgelegt durch: Konfiguration oder UseSetting
Umgebungsvariable: {PREFIX_}HTTPS_PORT

Diese Einstellung wird beim Erzwingen von HTTPS verwendet. Diese Einstellung bewirkt nicht, dass der Server auf dem spezifizierten Port lauscht. Das heißt, es ist möglich, Anforderungen versehentlich an einen ungenutzten Port umzuleiten.

webBuilder.UseSetting("https_port", "8080");

webBuilder.UseSetting("https_port", "8080");

webBuilder.UseSetting("https_ports", "8080");

Bevorzugtes Hosten von URLs

Gibt an, ob der Host auf die URLs lauschen soll, die mit der IWebHostBuilder konfiguriert sind, anstatt auf die mit der IServer Implementierung konfigurierten URLs.

Schlüssel: preferHostingUrls
Typ: bool (true/1 oder false/0)
Standard:false
Einstellen mithilfe von: Umgebungsvariable oder PreferHostingUrls
Umgebungsvariable: {PREFIX_}PREFERHOSTINGURLS

webBuilder.PreferHostingUrls(true);

webBuilder.PreferHostingUrls(true);

Hosting-Startvorgang verhindern

Verhindert das automatische Laden von Hosting-Start­assemblies, einschließlich derer, die durch die App-Assembly konfiguriert wurden. Weitere Informationen finden Sie unter Verwenden von Hostingstartassemblys in ASP.NET Core.

Schlüssel: preventHostingStartup
Typ: bool (true/1 oder false/0)
Standard:false
Einstellen mithilfe von: Umgebungsvariable oder UseSetting
Umgebungsvariable: {PREFIX_}PREVENTHOSTINGSTARTUP

webBuilder.UseSetting(WebHostDefaults.PreventHostingStartupKey, "true");

webBuilder.UseSetting(WebHostDefaults.PreventHostingStartupKey, "true");

Start-up-Montage

Gibt die Assembly an, in der nach der Startup-Klasse gesucht werden soll.

Schlüssel: startupAssembly
Typ: Zeichenfolge
Standard: Die Anwendungsassembly.
Einstellen mithilfe von: Umgebungsvariable oder UseStartup
Umgebungsvariable: {PREFIX_}STARTUPASSEMBLY

Sie können auf die Assembly verweisen, indem Sie auf den Namen (string) oder den Typ (TStartup) verweisen. Wenn mehrere UseStartup Methoden aufgerufen werden, hat der letzte Aufruf Vorrang.

webBuilder.UseStartup("StartupAssemblyName");

webBuilder.UseStartup<Startup>();

webBuilder.UseStartup("StartupAssemblyName");

webBuilder.UseStartup<Startup>();

Statusmeldungen unterdrücken

Gibt an, ob Hosting-Startstatusmeldungen unterdrückt werden sollen.

Schlüssel: suppressStatusMessages
Typ: bool (true/1 oder false/0)
Standard:false
Set using: Configuration or UseSetting
Umgebungsvariable: {PREFIX_}SUPPRESSSTATUSMESSAGES

webBuilder.UseSetting(WebHostDefaults.SuppressStatusMessagesKey, "true");

webBuilder.UseSetting(WebHostDefaults.SuppressStatusMessagesKey, "true");

Server-URLs

Gibt die IP-Adressen oder Hostadressen mit Ports und Protokollen an, denen der Server für Anforderungen lauschen soll.

Schlüssel: urls
Typ: Zeichenfolge
Standard: http://localhost:5000 und https://localhost:5001
Einstellen mithilfe von: Umgebungsvariable oder UseUrls
Umgebungsvariable: {PREFIX_}URLS

Wird auf eine durch Semikolons getrennte ; Liste von URL-Präfixen festgelegt, auf die der Server antworten soll. Beispielsweise http://localhost:123. Verwenden Sie ein Sternchen * als Platzhalter, um anzugeben, dass der Server auf Anforderungen an eine beliebige IP-Adresse oder einen Hostnamen lauschen soll, unter Verwendung des angegebenen Ports und Protokolls (z. B. http://*:5000). Das Protokoll (http:// oder https://) muss in jeder URL enthalten sein. Die unterstützten Formate variieren bei den verschiedenen Servern.

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

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

Kestrel verfügt über eine eigene API für die Endpunktkonfiguration. Weitere Informationen finden Sie unter Konfigurieren von Endpunkten für den Kestrel-Webserver von ASP.NET Core.

Webstamm

Legt den relativen Pfad für die statischen Objekte der App fest.

Schlüssel: webroot
Typ: Zeichenfolge
Standard:wwwroot
Set using: Umgebungsvariable oder UseWebRoot auf IWebHostBuilder
Umgebungsvariable: {PREFIX_}WEBROOT

Die WebRootPath Eigenschaft bestimmt den relativen Pfad zu den statischen Ressourcen der App.

Der Pfad zu {content root}/wwwroot muss existieren. Wenn der Pfad nicht vorhanden ist, wird ein nicht-operationeller Dateianbieter verwendet.

webBuilder.UseWebRoot("public");

webBuilder.UseWebRoot("public");

Weitere Informationen finden Sie unter:

• Grundlagen: Webroot-Verzeichnis
• Inhaltsstammverzeichnis

Verwalten der Lebensdauer des Hosts

Rufen Sie Methoden für die IHost Implementierung auf, um die Anwendung zu starten und zu beenden. Die Methoden wirken sich auf alle IHostedService im Dienstcontainer registrierten Implementierungen aus.

Der Unterschied zwischen den Run*- und Start*-Methoden besteht darin, dass Run*-Methoden warten, bis der Host abgeschlossen ist, bevor sie zurückgegeben werden, während Start*-Methoden sofort zurückgegeben werden. Die Run*-Methoden werden in der Regel in Konsolen-Apps verwendet, während die Start*-Methoden in der Regel in lang laufenden Diensten verwendet werden.

Run

Die Run Methode führt die App aus und blockiert den aufrufenden Thread, bis der Host heruntergefahren wird.

RunAsync

Die RunAsync Methode führt die App aus und gibt ein Task Objekt zurück, das abgeschlossen wird, wenn das Abbruchtoken oder das Herunterfahren ausgelöst wird.

RunConsoleAsync

Die RunConsoleAsync Methode ermöglicht die Konsolenunterstützung, erstellt und startet den Host und wartet darauf, dass STRG+C/SIGINT (Windows), STRG+C (macOS) oder SIGTERM zum Herunterfahren genutzt wird.

Start

Die Start Methode startet den Host synchron.

StartAsync

Die StartAsync-Methode startet den Host und gibt ein Task-Objekt zurück, das abgeschlossen wird, wenn das Abbruch-Token oder das Herunterfahren ausgelöst wird.

Die WaitForStartAsync-Methode wird zu Beginn von StartAsync aufgerufen, das wartet, bis es abgeschlossen ist, bevor Sie fortfahren. Diese Methode kann verwendet werden, um den Start zu verzögern, bis dieser durch ein externes Ereignis eingeleitet wird.

StopAsync

Die StopAsync Methode versucht, den Host innerhalb des angegebenen Timeouts zu beenden.

WaitForShutdown

Die WaitForShutdown Methode blockiert den aufrufenden Thread, bis die IHostLifetime-Implementierung das Herunterfahren über STRG+C/SIGINT (Windows), STRG+C (macOS) oder SIGTERM auslöst.

WaitForShutdownAsync

Die WaitForShutdownAsync-Methode gibt ein Task-Objekt zurück, das vollständig ausgeführt wird, wenn das Herunterfahren über das angegebene Token ausgelöst wird; anschließend wird die StopAsync-Methode aufgerufen.

public class Program
{
    private IHost _host;

    public Program()
    {
        _host = new HostBuilder()
            .Build();
    }

    public async Task StartAsync()
    {
        _host.StartAsync();
    }

    public async Task StopAsync()
    {
        using (_host)
        {
            await _host.StopAsync(TimeSpan.FromSeconds(5));
        }
    }
}

Verwandte Inhalte

• Hintergrundtasks mit gehosteten Diensten in ASP.NET Core
• Generische Hostquelle auf GitHub